Fix/to equal undefined comparison

packages/expect/src/jest-utils.ts

@@ -31,9 +31,10 @@ export function equals(
   b: unknown,
   customTesters?: Array<Tester>,
   strictCheck?: boolean,
+  ignoreUndefined = !strictCheck,
 ): boolean {
   customTesters = customTesters || []
-  return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey)
+  return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey, ignoreUndefined)
 }
 
 const functionToString = Function.prototype.toString
@@ -93,6 +94,7 @@ function eq(
   bStack: Array<unknown>,
   customTesters: Array<Tester>,
   hasKey: any,
+  ignoreUndefined = true,
 ): boolean {
   let result = true
 
@@ -207,23 +209,37 @@ function eq(
   let key
   let size = aKeys.length
 
+  // Get keys for b, filtering out undefined values if ignoreUndefined is true
+  const bKeys = keys(b, hasKey).filter(k => !ignoreUndefined || b[k] !== undefined)
+
   // Ensure that both objects contain the same number of properties before comparing deep equality.
-  if (keys(b, hasKey).length !== size) {
+  if (ignoreUndefined) {
+    const filteredAKeys = aKeys.filter(k => a[k] !== undefined)
+    if (filteredAKeys.length !== bKeys.length) {
+      return false
+    }
+  }
+  else if (bKeys.length !== size) {
     return false
   }
 
   while (size--) {
     key = aKeys[size]
 
+    // Skip undefined values when ignoreUndefined is true
+    if (ignoreUndefined && a[key] === undefined) {
+      continue
+    }
+
     // Deep compare each member
-    result
-      = hasKey(b, key)
-      && eq(a[key], b[key], aStack, bStack, customTesters, hasKey)
+    result = hasKey(b, key)
+    && eq(a[key], b[key], aStack, bStack, customTesters, hasKey, ignoreUndefined)
 
     if (!result) {
       return false
     }
   }
+
   // Remove the first object from the stack of traversed objects.
   aStack.pop()
   bStack.pop()

packages/ui/client/auto-imports.d.ts

@@ -344,4 +344,13 @@ declare global {
   // @ts-ignore
   export type { Component, ComponentPublicInstance, ComputedRef, DirectiveBinding, ExtractDefaultPropTypes, ExtractPropTypes, ExtractPublicPropTypes, InjectionKey, PropType, Ref, MaybeRef, MaybeRefOrGetter, VNode, WritableComputedRef } from 'vue'
   import('vue')
+  // @ts-ignore
+  export type { ViewportSize } from './composables/browser'
+  import('./composables/browser')
+  // @ts-ignore
+  export type { ModuleType, ModuleNode, ModuleLink, ModuleGraph, ModuleGraphController, ModuleGraphConfig, ModuleLabelItem } from './composables/module-graph'
+  import('./composables/module-graph')
+  // @ts-ignore
+  export type { Params } from './composables/params'
+  import('./composables/params')
 }

test/core/test/jest-expect.test.ts

@@ -1849,3 +1849,35 @@ it('diff', () => {
   snapshotError(() => expect({ hello: 'world' }).toBeUndefined())
   snapshotError(() => expect({ hello: 'world' }).toBeNull())
 })
+
+describe('undefined property handling', () => {
+  it('toEqual ignores undefined properties', () => {
+    const obj1 = {
+      foo: 'bar',
+      qux: 'qux',
+    }
+
+    const obj2 = {
+      foo: 'bar',
+      extra: undefined,
+      qux: 'qux',
+    }
+
+    expect(obj1).toEqual(obj2)
+  })
+
+  it('toStrictEqual considers undefined properties', () => {
+    const obj1 = {
+      foo: 'bar',
+      qux: 'qux',
+    }
+
+    const obj2 = {
+      foo: 'bar',
+      extra: undefined,
+      qux: 'qux',
+    }
+
+    expect(() => expect(obj1).toStrictEqual(obj2)).toThrow()
+  })
+})