@tanstack/db 0.1.8 → 0.1.9

package/src/proxy.ts

@@ -3,6 +3,8 @@
  * and provides a way to retrieve those changes.
  */
 
+import { deepEquals, isTemporal } from "./utils"
+
 /**
  * Simple debug utility that only logs when debug mode is enabled
  * Set DEBUG to true in localStorage to enable debug logging
@@ -133,6 +135,13 @@ function deepClone<T extends unknown>(
     return clone as unknown as T
   }
 
+  // Handle Temporal objects
+  if (isTemporal(obj)) {
+    // Temporal objects are immutable, so we can return them directly
+    // This preserves all their internal state correctly
+    return obj
+  }
+
   const clone = {} as Record<string | symbol, unknown>
   visited.set(obj as object, clone)
 
@@ -156,107 +165,6 @@ function deepClone<T extends unknown>(
   return clone as T
 }
 
-/**
- * Deep equality check that handles special types like Date, RegExp, Map, and Set
- */
-function deepEqual<T>(a: T, b: T): boolean {
-  // Handle primitive types
-  if (a === b) return true
-
-  // If either is null or not an object, they're not equal
-  if (
-    a === null ||
-    b === null ||
-    typeof a !== `object` ||
-    typeof b !== `object`
-  ) {
-    return false
-  }
-
-  // Handle Date objects
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime()
-  }
-
-  // Handle RegExp objects
-  if (a instanceof RegExp && b instanceof RegExp) {
-    return a.source === b.source && a.flags === b.flags
-  }
-
-  // Handle Map objects
-  if (a instanceof Map && b instanceof Map) {
-    if (a.size !== b.size) return false
-
-    const entries = Array.from(a.entries())
-    for (const [key, val] of entries) {
-      if (!b.has(key) || !deepEqual(val, b.get(key))) {
-        return false
-      }
-    }
-
-    return true
-  }
-
-  // Handle Set objects
-  if (a instanceof Set && b instanceof Set) {
-    if (a.size !== b.size) return false
-
-    // Convert to arrays for comparison
-    const aValues = Array.from(a)
-    const bValues = Array.from(b)
-
-    // Simple comparison for primitive values
-    if (aValues.every((val) => typeof val !== `object`)) {
-      return aValues.every((val) => b.has(val))
-    }
-
-    // For objects in sets, we need to do a more complex comparison
-    // This is a simplified approach and may not work for all cases
-    return aValues.length === bValues.length
-  }
-
-  // Handle arrays
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false
-
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i])) return false
-    }
-
-    return true
-  }
-
-  // Handle TypedArrays
-  if (
-    ArrayBuffer.isView(a) &&
-    ArrayBuffer.isView(b) &&
-    !(a instanceof DataView) &&
-    !(b instanceof DataView)
-  ) {
-    const typedA = a as unknown as TypedArray
-    const typedB = b as unknown as TypedArray
-    if (typedA.length !== typedB.length) return false
-
-    for (let i = 0; i < typedA.length; i++) {
-      if (typedA[i] !== typedB[i]) return false
-    }
-
-    return true
-  }
-
-  // Handle plain objects
-  const keysA = Object.keys(a as object)
-  const keysB = Object.keys(b as object)
-
-  if (keysA.length !== keysB.length) return false
-
-  return keysA.every(
-    (key) =>
-      Object.prototype.hasOwnProperty.call(b, key) &&
-      deepEqual((a as any)[key], (b as any)[key])
-  )
-}
-
 let count = 0
 function getProxyCount() {
   count += 1
@@ -392,7 +300,7 @@ export function createChangeProxy<
         )
 
         // If the value is not equal to original, something is still changed
-        if (!deepEqual(currentValue, originalValue)) {
+        if (!deepEquals(currentValue, originalValue)) {
           debugLog(`Property ${String(prop)} is different, returning false`)
           return false
         }
@@ -411,7 +319,7 @@ export function createChangeProxy<
         const originalValue = (state.originalObject as any)[sym]
 
         // If the value is not equal to original, something is still changed
-        if (!deepEqual(currentValue, originalValue)) {
+        if (!deepEquals(currentValue, originalValue)) {
           debugLog(`Symbol property is different, returning false`)
           return false
         }
@@ -741,12 +649,13 @@ export function createChangeProxy<
           return value.bind(ptarget)
         }
 
-        // If the value is an object, create a proxy for it
+        // If the value is an object (but not Date, RegExp, or Temporal), create a proxy for it
         if (
           value &&
           typeof value === `object` &&
           !((value as any) instanceof Date) &&
-          !((value as any) instanceof RegExp)
+          !((value as any) instanceof RegExp) &&
+          !isTemporal(value)
         ) {
           // Create a parent reference for the nested object
           const nestedParent = {
@@ -779,11 +688,11 @@ export function createChangeProxy<
         )
 
         // Only track the change if the value is actually different
-        if (!deepEqual(currentValue, value)) {
+        if (!deepEquals(currentValue, value)) {
           // Check if the new value is equal to the original value
           // Important: Use the originalObject to get the true original value
           const originalValue = changeTracker.originalObject[prop as keyof T]
-          const isRevertToOriginal = deepEqual(value, originalValue)
+          const isRevertToOriginal = deepEquals(value, originalValue)
           debugLog(
             `value:`,
             value,

package/src/utils.ts

@@ -2,8 +2,14 @@
  * Generic utility functions
  */
 
+interface TypedArray {
+  length: number
+  [index: number]: number
+}
+
 /**
  * Deep equality function that compares two values recursively
+ * Handles primitives, objects, arrays, Date, RegExp, Map, Set, TypedArrays, and Temporal objects
  *
  * @param a - First value to compare
  * @param b - Second value to compare
@@ -14,6 +20,8 @@
  * deepEquals({ a: 1, b: 2 }, { b: 2, a: 1 }) // true (property order doesn't matter)
  * deepEquals([1, { x: 2 }], [1, { x: 2 }]) // true
  * deepEquals({ a: 1 }, { a: 2 }) // false
+ * deepEquals(new Date('2023-01-01'), new Date('2023-01-01')) // true
+ * deepEquals(new Map([['a', 1]]), new Map([['a', 1]])) // true
  * ```
  */
 export function deepEquals(a: any, b: any): boolean {
@@ -37,6 +45,102 @@ function deepEqualsInternal(
   // Handle different types
   if (typeof a !== typeof b) return false
 
+  // Handle Date objects
+  if (a instanceof Date) {
+    if (!(b instanceof Date)) return false
+    return a.getTime() === b.getTime()
+  }
+
+  // Handle RegExp objects
+  if (a instanceof RegExp) {
+    if (!(b instanceof RegExp)) return false
+    return a.source === b.source && a.flags === b.flags
+  }
+
+  // Handle Map objects - only if both are Maps
+  if (a instanceof Map) {
+    if (!(b instanceof Map)) return false
+    if (a.size !== b.size) return false
+
+    // Check for circular references
+    if (visited.has(a)) {
+      return visited.get(a) === b
+    }
+    visited.set(a, b)
+
+    const entries = Array.from(a.entries())
+    const result = entries.every(([key, val]) => {
+      return b.has(key) && deepEqualsInternal(val, b.get(key), visited)
+    })
+
+    visited.delete(a)
+    return result
+  }
+
+  // Handle Set objects - only if both are Sets
+  if (a instanceof Set) {
+    if (!(b instanceof Set)) return false
+    if (a.size !== b.size) return false
+
+    // Check for circular references
+    if (visited.has(a)) {
+      return visited.get(a) === b
+    }
+    visited.set(a, b)
+
+    // Convert to arrays for comparison
+    const aValues = Array.from(a)
+    const bValues = Array.from(b)
+
+    // Simple comparison for primitive values
+    if (aValues.every((val) => typeof val !== `object`)) {
+      visited.delete(a)
+      return aValues.every((val) => b.has(val))
+    }
+
+    // For objects in sets, we need to do a more complex comparison
+    // This is a simplified approach and may not work for all cases
+    const result = aValues.length === bValues.length
+    visited.delete(a)
+    return result
+  }
+
+  // Handle TypedArrays
+  if (
+    ArrayBuffer.isView(a) &&
+    ArrayBuffer.isView(b) &&
+    !(a instanceof DataView) &&
+    !(b instanceof DataView)
+  ) {
+    const typedA = a as unknown as TypedArray
+    const typedB = b as unknown as TypedArray
+    if (typedA.length !== typedB.length) return false
+
+    for (let i = 0; i < typedA.length; i++) {
+      if (typedA[i] !== typedB[i]) return false
+    }
+
+    return true
+  }
+
+  // Handle Temporal objects
+  // Check if both are Temporal objects of the same type
+  if (isTemporal(a) && isTemporal(b)) {
+    const aTag = getStringTag(a)
+    const bTag = getStringTag(b)
+
+    // If they're different Temporal types, they're not equal
+    if (aTag !== bTag) return false
+
+    // Use Temporal's built-in equals method if available
+    if (typeof a.equals === `function`) {
+      return a.equals(b)
+    }
+
+    // Fallback to toString comparison for other types
+    return a.toString() === b.toString()
+  }
+
   // Handle arrays
   if (Array.isArray(a)) {
     if (!Array.isArray(b) || a.length !== b.length) return false
@@ -84,3 +188,24 @@ function deepEqualsInternal(
   // For primitives that aren't strictly equal
   return false
 }
+
+const temporalTypes = [
+  `Temporal.Duration`,
+  `Temporal.Instant`,
+  `Temporal.PlainDate`,
+  `Temporal.PlainDateTime`,
+  `Temporal.PlainMonthDay`,
+  `Temporal.PlainTime`,
+  `Temporal.PlainYearMonth`,
+  `Temporal.ZonedDateTime`,
+]
+
+function getStringTag(a: any): any {
+  return a[Symbol.toStringTag]
+}
+
+/** Checks if the value is a Temporal object by checking for the Temporal brand */
+export function isTemporal(a: any): boolean {
+  const tag = getStringTag(a)
+  return typeof tag === `string` && temporalTypes.includes(tag)
+}