@tanstack/db-ivm 0.1.22 → 0.1.25

package/src/operators/groupBy.ts

@@ -237,7 +237,10 @@ export function min<T, V extends CanMinMax>(
     reduce: (values) => {
       let minValue: V | undefined
       for (const [value, _multiplicity] of values) {
-        if (!minValue || (value && value < minValue)) {
+        if (
+          value !== undefined &&
+          (minValue === undefined || value < minValue)
+        ) {
           minValue = value
         }
       }
@@ -267,7 +270,10 @@ export function max<T, V extends CanMinMax>(
     reduce: (values) => {
       let maxValue: V | undefined
       for (const [value, _multiplicity] of values) {
-        if (!maxValue || (value && value > maxValue)) {
+        if (
+          value !== undefined &&
+          (maxValue === undefined || value > maxValue)
+        ) {
           maxValue = value
         }
       }

package/src/utils.ts

@@ -1,3 +1,5 @@
+import { isTemporal } from './hashing/temporal.js'
+
 /**
  * Simple assertion function for runtime checks.
  * Throws an error if the condition is false.
@@ -11,36 +13,6 @@ export function assert(
   }
 }
 
-/**
- * A map that returns a default value for keys that are not present.
- */
-export class DefaultMap<K, V> extends Map<K, V> {
-  constructor(
-    private defaultValue: () => V,
-    entries?: Iterable<[K, V]>,
-  ) {
-    super(entries)
-  }
-
-  get(key: K): V {
-    if (!this.has(key)) {
-      // this.set(key, this.defaultValue())
-      return this.defaultValue()
-    }
-    return super.get(key)!
-  }
-
-  /**
-   * Update the value for a key using a function.
-   */
-  update(key: K, updater: (value: V) => V): V {
-    const value = this.get(key)
-    const newValue = updater(value)
-    this.set(key, newValue)
-    return newValue
-  }
-}
-
 // JS engines have various limits on how many args can be passed to a function
 // with a spread operator, so we need to split the operation into chunks
 // 32767 is the max for Chrome 14, all others are higher
@@ -79,55 +51,25 @@ export function binarySearch<T>(
 }
 
 /**
- * Utility for generating unique IDs for objects and values.
- * Uses WeakMap for object reference tracking and consistent hashing for primitives.
+ * A string identity within one consolidation: primitives by value, objects,
+ * functions, and symbols by identity.
  */
-export class ObjectIdGenerator {
-  private objectIds = new WeakMap<object, number>()
-  private nextId = 0
-
-  /**
-   * Get a unique identifier for any value.
-   * - Objects: Uses WeakMap for reference-based identity
-   * - Primitives: Uses consistent string-based hashing
-   */
-  getId(value: any): number {
-    // For primitives, use a simple hash of their string representation
-    if (typeof value !== `object` || value === null) {
-      const str = String(value)
-      let hashValue = 0
-      for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i)
-        hashValue = (hashValue << 5) - hashValue + char
-        hashValue = hashValue & hashValue // Convert to 32-bit integer
-      }
-      return hashValue
-    }
-
-    // For objects, use WeakMap to assign unique IDs
-    if (!this.objectIds.has(value)) {
-      this.objectIds.set(value, this.nextId++)
-    }
-    return this.objectIds.get(value)!
-  }
-
-  /**
-   * Get a string representation of the ID for use in composite keys.
-   */
-  getStringId(value: any): string {
-    if (value === null) return `null`
-    if (value === undefined) return `undefined`
-    if (typeof value !== `object`) return `str_${String(value)}`
-
-    return `obj_${this.getId(value)}`
+export function getStringId(
+  value: unknown,
+  referenceIds: Map<object | symbol, number>,
+): string {
+  if (value === null) return `null`
+  if (value === undefined) return `undefined`
+  const type = typeof value
+  if (type === `object` || type === `function` || type === `symbol`) {
+    const reference = value as object | symbol
+    let id = referenceIds.get(reference)
+    if (id === undefined) referenceIds.set(reference, (id = referenceIds.size))
+    return `ref_${id}`
   }
+  return `${type}_${String(value)}`
 }
 
-/**
- * Global instance for cases where a shared object ID space is needed.
- */
-export const globalObjectIdGenerator = new ObjectIdGenerator()
-
 export function* concatIterable<T>(
   ...iterables: Array<Iterable<T>>
 ): Iterable<T> {
@@ -209,6 +151,7 @@ type CanonicalValue =
   | readonly [`bigint`, string]
   | readonly [`string`, string]
   | readonly [`date`, number | `Invalid`]
+  | readonly [`temporal`, string, string]
   | readonly [`regexp`, string, string]
   | readonly [`bytes`, Array<number>]
   | readonly [`array`, Array<CanonicalValue>]
@@ -265,6 +208,7 @@ function isJsonSafeStructuralValue(
       value instanceof Date ||
       value instanceof RegExp ||
       value instanceof Uint8Array ||
+      isTemporal(value) ||
       value instanceof Map ||
       value instanceof Set
     ) {
@@ -348,6 +292,10 @@ function toCanonicalValue(
       return [`bytes`, Array.from(value)]
     }
 
+    if (isTemporal(value)) {
+      return [`temporal`, value[Symbol.toStringTag], value.toString()]
+    }
+
     if (Array.isArray(value)) {
       return [`array`, value.map((item) => toCanonicalValue(item, ancestors))]
     }