@tanstack/db-ivm 0.1.13 → 0.1.15

package/src/indexes.ts

@@ -33,9 +33,9 @@
  * Prefixes extracted from array values: `['prefix', 'suffix']` → prefix='prefix'
  */
 
-import { MultiSet } from "./multiset.js"
-import { hash } from "./hashing/index.js"
-import type { Hash } from "./hashing/index.js"
+import { MultiSet } from './multiset.js'
+import { hash } from './hashing/index.js'
+import type { Hash } from './hashing/index.js'
 
 // We use a symbol to represent the absence of a prefix, unprefixed values a stored
 // against this key.
@@ -183,7 +183,7 @@ export class Index<TKey, TValue, TPrefix = any> {
     return `Index(${JSON.stringify(
       [...this.entries()],
       undefined,
-      indent ? 2 : undefined
+      indent ? 2 : undefined,
     )})`
   }
 
@@ -325,7 +325,7 @@ export class Index<TKey, TValue, TPrefix = any> {
         key,
         mapOrSingleValue,
         value,
-        multiplicity
+        multiplicity,
       )
       return
     }
@@ -362,7 +362,7 @@ export class Index<TKey, TValue, TPrefix = any> {
     key: TKey,
     currentSingleValue: SingleValue<TValue>,
     newValue: TValue,
-    multiplicity: number
+    multiplicity: number,
   ) {
     const [currentValue, currentMultiplicity] = currentSingleValue
 
@@ -438,7 +438,7 @@ export class Index<TKey, TValue, TPrefix = any> {
    * @returns A multiset of the joined values.
    */
   join<TValue2>(
-    other: Index<TKey, TValue2>
+    other: Index<TKey, TValue2>,
   ): MultiSet<[TKey, [TValue, TValue2]]> {
     const result: Array<[[TKey, [TValue, TValue2]], number]> = []
     // We want to iterate over the smaller of the two indexes to reduce the
@@ -499,7 +499,7 @@ function getPrefix<TValue, TPrefix>(value: TValue): TPrefix | NO_PREFIX {
  * @returns True if the value is a single value, false otherwise.
  */
 function isSingleValue<TValue>(
-  value: SingleValue<TValue> | unknown
+  value: SingleValue<TValue> | unknown,
 ): value is SingleValue<TValue> {
   return Array.isArray(value)
 }

package/src/multiset.ts

@@ -2,8 +2,8 @@ import {
   DefaultMap,
   chunkedArrayPush,
   globalObjectIdGenerator,
-} from "./utils.js"
-import { hash } from "./hashing/index.js"
+} from './utils.js'
+import { hash } from './hashing/index.js'
 
 export type MultiSetArray<T> = Array<[T, number]>
 export type KeyedData<T> = [key: string, value: T]
@@ -35,7 +35,7 @@ export class MultiSet<T> {
    */
   map<U>(f: (data: T) => U): MultiSet<U> {
     return new MultiSet(
-      this.#inner.map(([data, multiplicity]) => [f(data), multiplicity])
+      this.#inner.map(([data, multiplicity]) => [f(data), multiplicity]),
     )
   }
 
@@ -51,7 +51,7 @@ export class MultiSet<T> {
    */
   negate(): MultiSet<T> {
     return new MultiSet(
-      this.#inner.map(([data, multiplicity]) => [data, -multiplicity])
+      this.#inner.map(([data, multiplicity]) => [data, -multiplicity]),
     )
   }
 
@@ -142,7 +142,7 @@ export class MultiSet<T> {
       const compositeKey = key + `|` + valueId
       consolidated.set(
         compositeKey,
-        (consolidated.get(compositeKey) || 0) + multiplicity
+        (consolidated.get(compositeKey) || 0) + multiplicity,
       )
 
       // Store the original data for the first occurrence

package/src/operators/concat.ts

@@ -1,6 +1,6 @@
-import { BinaryOperator, DifferenceStreamWriter } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
+import { BinaryOperator, DifferenceStreamWriter } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
 
 /**
  * Operator that concatenates two input streams
@@ -22,7 +22,7 @@ export class ConcatOperator<T, T2> extends BinaryOperator<T | T2> {
  * @param other - The other stream to concatenate
  */
 export function concat<T, T2>(
-  other: IStreamBuilder<T2>
+  other: IStreamBuilder<T2>,
 ): PipedOperator<T, T | T2> {
   return (stream: IStreamBuilder<T | T2>): IStreamBuilder<T | T2> => {
     if (stream.graph !== other.graph) {
@@ -30,13 +30,13 @@ export function concat<T, T2>(
     }
     const output = new StreamBuilder<T | T2>(
       stream.graph,
-      new DifferenceStreamWriter<T | T2>()
+      new DifferenceStreamWriter<T | T2>(),
     )
     const operator = new ConcatOperator<T, T2>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       other.connectReader(),
-      output.writer
+      output.writer,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/consolidate.ts

@@ -1,7 +1,7 @@
-import { DifferenceStreamWriter, UnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { MultiSet } from "../multiset.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { MultiSet } from '../multiset.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
 
 /**
  * Operator that consolidates collections
@@ -36,12 +36,12 @@ export function consolidate<T>(): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new ConsolidateOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
-      output.writer
+      output.writer,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/count.ts

@@ -1,8 +1,8 @@
-import { DifferenceStreamWriter } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { ReduceOperator } from "./reduce.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { DifferenceStreamWriter } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { ReduceOperator } from './reduce.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 /**
  * Operator that counts elements by key (version-free)
@@ -11,7 +11,7 @@ export class CountOperator<K, V> extends ReduceOperator<K, V, number> {
   constructor(
     id: number,
     inputA: DifferenceStreamReader<[K, V]>,
-    output: DifferenceStreamWriter<[K, number]>
+    output: DifferenceStreamWriter<[K, number]>,
   ) {
     const countInner = (vals: Array<[V, number]>): Array<[number, number]> => {
       let totalCount = 0
@@ -34,16 +34,16 @@ export function count<
   T,
 >() {
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<KeyValue<KType, number>> => {
     const output = new StreamBuilder<KeyValue<KType, number>>(
       stream.graph,
-      new DifferenceStreamWriter<KeyValue<KType, number>>()
+      new DifferenceStreamWriter<KeyValue<KType, number>>(),
     )
     const operator = new CountOperator<KType, VType>(
       stream.graph.getNextOperatorId(),
       stream.connectReader() as DifferenceStreamReader<KeyValue<KType, VType>>,
-      output.writer
+      output.writer,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/debug.ts

@@ -1,7 +1,7 @@
-import { DifferenceStreamWriter, UnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { DifferenceStreamReader } from "../graph.js"
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { DifferenceStreamReader } from '../graph.js'
 
 /**
  * Operator that logs debug information about the stream
@@ -15,7 +15,7 @@ export class DebugOperator<T> extends UnaryOperator<T> {
     inputA: DifferenceStreamReader<T>,
     output: DifferenceStreamWriter<T>,
     name: string,
-    indent: boolean = false
+    indent: boolean = false,
   ) {
     super(id, inputA, output)
     this.#name = name
@@ -37,19 +37,19 @@ export class DebugOperator<T> extends UnaryOperator<T> {
  */
 export function debug<T>(
   name: string,
-  indent: boolean = false
+  indent: boolean = false,
 ): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new DebugOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
       name,
-      indent
+      indent,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/distinct.ts

@@ -1,10 +1,10 @@
-import { DifferenceStreamWriter, UnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { hash } from "../hashing/index.js"
-import { MultiSet } from "../multiset.js"
-import type { Hash } from "../hashing/index.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { hash } from '../hashing/index.js'
+import { MultiSet } from '../multiset.js'
+import type { Hash } from '../hashing/index.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 type Multiplicity = number
 
@@ -23,7 +23,7 @@ export class DistinctOperator<
     id: number,
     input: DifferenceStreamReader<T>,
     output: DifferenceStreamWriter<KeyValue<number, GetValue<T>>>,
-    by: (value: T) => any = (value: T) => value
+    by: (value: T) => any = (value: T) => value,
   ) {
     super(id, input, output)
     this.#by = by
@@ -83,18 +83,18 @@ export class DistinctOperator<
  * Removes duplicate values
  */
 export function distinct<T extends KeyValue<any, any>>(
-  by: (value: T) => any = (value: T) => value
+  by: (value: T) => any = (value: T) => value,
 ) {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new DistinctOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
-      by
+      by,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/filter.ts

@@ -1,8 +1,8 @@
-import { DifferenceStreamWriter, LinearUnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that filters elements from the input stream
@@ -14,7 +14,7 @@ export class FilterOperator<T> extends LinearUnaryOperator<T, T> {
     id: number,
     inputA: DifferenceStreamReader<T>,
     output: DifferenceStreamWriter<T>,
-    f: (data: T) => boolean
+    f: (data: T) => boolean,
   ) {
     super(id, inputA, output)
     this.#f = f
@@ -33,13 +33,13 @@ export function filter<T>(f: (data: T) => boolean): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new FilterOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
-      f
+      f,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/filterBy.ts

@@ -1,7 +1,7 @@
-import { map } from "./map.js"
-import { innerJoin } from "./join.js"
-import { consolidate } from "./consolidate.js"
-import type { IStreamBuilder, KeyValue, PipedOperator } from "../types.js"
+import { map } from './map.js'
+import { innerJoin } from './join.js'
+import { consolidate } from './consolidate.js'
+import type { IStreamBuilder, KeyValue, PipedOperator } from '../types.js'
 
 /**
  * Filters the elements of a keyed stream, by keys of another stream.
@@ -15,16 +15,16 @@ export function filterBy<
   V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, unknown>>
+  other: IStreamBuilder<KeyValue<K, unknown>>,
 ): PipedOperator<T, KeyValue<K, V1>> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<KeyValue<K, V1>> => {
     const otherKeys = other.pipe(
-      map(([key, _]) => [key, null] as KeyValue<K, null>)
+      map(([key, _]) => [key, null] as KeyValue<K, null>),
     )
     return stream.pipe(
       innerJoin(otherKeys),
       map(([key, [value, _]]) => [key, value] as KeyValue<K, V1>),
-      consolidate()
+      consolidate(),
     )
   }
 }

package/src/operators/groupBy.ts

@@ -1,6 +1,7 @@
-import { map } from "./map.js"
-import { reduce } from "./reduce.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { serializeValue } from '../utils.js'
+import { map } from './map.js'
+import { reduce } from './reduce.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 type GroupKey = Record<string, unknown>
 
@@ -26,7 +27,7 @@ type AggregatesReturnType<T, A> = {
 }
 
 function isPipedAggregateFunction<T, R>(
-  aggregate: AggregateFunction<T, R>
+  aggregate: AggregateFunction<T, R>,
 ): aggregate is PipedAggregateFunction<T, R> {
   return `pipe` in aggregate
 }
@@ -45,20 +46,20 @@ export function groupBy<
 
   const basicAggregates = Object.fromEntries(
     Object.entries(aggregates).filter(
-      ([_, aggregate]) => !isPipedAggregateFunction(aggregate)
-    )
+      ([_, aggregate]) => !isPipedAggregateFunction(aggregate),
+    ),
   ) as Record<string, BasicAggregateFunction<T, any, any>>
 
   // @ts-expect-error - TODO: we don't use this yet, but we will
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const pipedAggregates = Object.fromEntries(
     Object.entries(aggregates).filter(([_, aggregate]) =>
-      isPipedAggregateFunction(aggregate)
-    )
+      isPipedAggregateFunction(aggregate),
+    ),
   ) as Record<string, PipedAggregateFunction<T, any>>
 
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<KeyValue<string, ResultType>> => {
     // Special key to store the original key object
     const KEY_SENTINEL = `__original_key__`
@@ -67,7 +68,7 @@ export function groupBy<
     const withKeysAndValues = stream.pipe(
       map((data) => {
         const key = keyExtractor(data)
-        const keyString = JSON.stringify(key)
+        const keyString = serializeValue(key)
 
         // Create values object with pre-aggregated values
         const values: Record<string, unknown> = {}
@@ -81,7 +82,7 @@ export function groupBy<
         }
 
         return [keyString, values] as KeyValue<string, Record<string, unknown>>
-      })
+      }),
     )
 
     // Then reduce to compute aggregates
@@ -107,13 +108,13 @@ export function groupBy<
         // Apply each aggregate function
         for (const [name, aggregate] of Object.entries(basicAggregates)) {
           const preValues = values.map(
-            ([v, m]) => [v[name], m] as [any, number]
+            ([v, m]) => [v[name], m] as [any, number],
           )
           result[name] = aggregate.reduce(preValues)
         }
 
         return [[result, 1]]
-      })
+      }),
     )
 
     // Finally map to extract the key and include all values
@@ -139,7 +140,7 @@ export function groupBy<
 
         // Return with the string key instead of the object
         return [keyString, result] as KeyValue<string, ResultType>
-      })
+      }),
     )
   }
 }
@@ -148,7 +149,7 @@ export function groupBy<
  * Creates a sum aggregate function
  */
 export function sum<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, number> {
   return {
     preMap: (data: T) => valueExtractor(data),
@@ -166,7 +167,7 @@ export function sum<T>(
  * Creates a count aggregate function
  */
 export function count<T>(
-  valueExtractor: (value: T) => any = (v) => v
+  valueExtractor: (value: T) => any = (v) => v,
 ): AggregateFunction<T, number, number> {
   return {
     // Count only not-null values (the `== null` comparison gives true for both null and undefined)
@@ -185,7 +186,7 @@ export function count<T>(
  * Creates an average aggregate function
  */
 export function avg<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, { sum: number; count: number }> {
   return {
     preMap: (data: T) => ({
@@ -222,10 +223,10 @@ export function min<T extends CanMinMax>(): AggregateFunction<
   T | undefined
 >
 export function min<T, V extends CanMinMax>(
-  valueExtractor: (value: T) => V
+  valueExtractor: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined>
 export function min<T, V extends CanMinMax>(
-  valueExtractor?: (value: T) => V
+  valueExtractor?: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined> {
   const extractor = valueExtractor ?? ((v: T) => v as unknown as V)
   return {
@@ -252,10 +253,10 @@ export function max<T extends CanMinMax>(): AggregateFunction<
   T | undefined
 >
 export function max<T, V extends CanMinMax>(
-  valueExtractor: (value: T) => V
+  valueExtractor: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined>
 export function max<T, V extends CanMinMax>(
-  valueExtractor?: (value: T) => V
+  valueExtractor?: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined> {
   const extractor = valueExtractor ?? ((v: T) => v as unknown as V)
   return {
@@ -278,7 +279,7 @@ export function max<T, V extends CanMinMax>(
  * @param valueExtractor Function to extract a numeric value from each data entry
  */
 export function median<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, Array<number>> {
   return {
     preMap: (data: T) => [valueExtractor(data)],
@@ -326,7 +327,7 @@ export function median<T>(
  * @param valueExtractor Function to extract a value from each data entry
  */
 export function mode<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, Map<number, number>> {
   return {
     preMap: (data: T) => {