handle Symbol properties and non-enumerable properties in replaceEqualDeep

packages/router-core/src/utils.ts

@@ -213,10 +213,18 @@ export function replaceEqualDeep<T>(prev: any, _next: T): T {
 
   const array = isPlainArray(prev) && isPlainArray(next)
 
-  if (array || (isPlainObject(prev) && isPlainObject(next))) {
-    const prevItems = array ? prev : Object.keys(prev)
+  if (array || (isSimplePlainObject(prev) && isSimplePlainObject(next))) {
+    const prevItems = array
+      ? prev
+      : (Object.keys(prev) as Array<unknown>).concat(
+          Object.getOwnPropertySymbols(prev),
+        )
     const prevSize = prevItems.length
-    const nextItems = array ? next : Object.keys(next)
+    const nextItems = array
+      ? next
+      : (Object.keys(next) as Array<unknown>).concat(
+          Object.getOwnPropertySymbols(next),
+        )
     const nextSize = nextItems.length
     const copy: any = array ? [] : {}
 
@@ -245,6 +253,19 @@ export function replaceEqualDeep<T>(prev: any, _next: T): T {
   return next
 }
 
+/**
+ * A wrapper around `isPlainObject` with additional checks to ensure that it is not
+ * only a plain object, but also one that is "clone-friendly" (doesn't have any
+ * non-enumerable properties).
+ */
+function isSimplePlainObject(o: any) {
+  return (
+    // all the checks from isPlainObject are more likely to hit so we perform them first
+    isPlainObject(o) &&
+    Object.getOwnPropertyNames(o).length === Object.keys(o).length
+  )
+}
+
 // Copied from: https://github.com/jonschlinkert/is-plain-object
 export function isPlainObject(o: any) {
   if (!hasObjectPrototype(o)) {

packages/router-core/tests/utils.test.ts

@@ -29,6 +29,44 @@ describe('replaceEqualDeep', () => {
     expect(result).toStrictEqual(obj2)
   })
 
+  describe('symbol properties', () => {
+    it('should look at symbol properties in the object comparison', () => {
+      const propertyKey = Symbol('property')
+      const obj1 = { a: 1, [propertyKey]: 2 }
+      const obj2 = { a: 1, [propertyKey]: 3 }
+      const result = replaceEqualDeep(obj1, obj2)
+      expect(result).toStrictEqual(obj2)
+    })
+
+    it('should copy over symbol properties when creating a new object', () => {
+      const propertyKey = Symbol('property')
+      const obj1 = { a: 1, [propertyKey]: 2 }
+      const obj2 = { a: 3, [propertyKey]: 2 }
+      const result = replaceEqualDeep(obj1, obj2)
+      expect(result).toStrictEqual(obj2)
+    })
+  })
+
+  describe('non-enumerable properties', () => {
+    it('should treat objects with non-enumerable properties as non-plain (no need for property comparisons)', () => {
+      const obj1: { a: number; b?: number } = { a: 1 }
+      Object.defineProperty(obj1, 'b', { enumerable: false, value: 2 })
+      const obj2: { a: number; b?: number } = { a: 1 }
+      Object.defineProperty(obj2, 'b', { enumerable: false, value: 3 })
+      const result = replaceEqualDeep(obj1, obj2)
+      expect(result).toBe(obj2)
+    })
+
+    it("should treat objects with non-enumerable properties as non-plain (copying doesn't happen)", () => {
+      const obj1: { a: number; b?: number } = { a: 1 }
+      Object.defineProperty(obj1, 'b', { enumerable: false, value: 2 })
+      const obj2: { a: number; b?: number } = { a: 3 }
+      Object.defineProperty(obj2, 'b', { enumerable: false, value: 2 })
+      const result = replaceEqualDeep(obj1, obj2)
+      expect(result).toBe(obj2)
+    })
+  })
+
   it('should properly handle non-existent keys', () => {
     const obj1 = { a: 2, c: 123 }
     const obj2 = { a: 2, c: 123, b: undefined }