@tanstack/db-ivm 0.1.26 → 0.2.0

package/src/operators/join.ts

@@ -282,93 +282,3 @@ export function join<
     return output
   }
 }
-
-/**
- * Joins two input streams (inner join)
- * @param other - The other stream to join with
- */
-export function innerJoin<
-  K,
-  V1 extends (T extends KeyValue<infer _KT, infer VT> ? VT : never),
-  V2,
-  T,
->(
-  other: IStreamBuilder<KeyValue<K, V2>>,
-): PipedOperator<T, KeyValue<K, [V1, V2]>> {
-  return join(other, `inner`) as unknown as PipedOperator<
-    T,
-    KeyValue<K, [V1, V2]>
-  >
-}
-
-/**
- * Joins two input streams (anti join)
- * @param other - The other stream to join with
- */
-export function antiJoin<
-  K,
-  V1 extends (T extends KeyValue<infer _KT, infer VT> ? VT : never),
-  V2,
-  T,
->(
-  other: IStreamBuilder<KeyValue<K, V2>>,
-): PipedOperator<T, KeyValue<K, [V1, null]>> {
-  return join(other, `anti`) as unknown as PipedOperator<
-    T,
-    KeyValue<K, [V1, null]>
-  >
-}
-
-/**
- * Joins two input streams (left join)
- * @param other - The other stream to join with
- */
-export function leftJoin<
-  K,
-  V1 extends (T extends KeyValue<infer _KT, infer VT> ? VT : never),
-  V2,
-  T,
->(
-  other: IStreamBuilder<KeyValue<K, V2>>,
-): PipedOperator<T, KeyValue<K, [V1, V2 | null]>> {
-  return join(other, `left`) as unknown as PipedOperator<
-    T,
-    KeyValue<K, [V1, V2 | null]>
-  >
-}
-
-/**
- * Joins two input streams (right join)
- * @param other - The other stream to join with
- */
-export function rightJoin<
-  K,
-  V1 extends (T extends KeyValue<infer _KT, infer VT> ? VT : never),
-  V2,
-  T,
->(
-  other: IStreamBuilder<KeyValue<K, V2>>,
-): PipedOperator<T, KeyValue<K, [V1 | null, V2]>> {
-  return join(other, `right`) as unknown as PipedOperator<
-    T,
-    KeyValue<K, [V1 | null, V2]>
-  >
-}
-
-/**
- * Joins two input streams (full join)
- * @param other - The other stream to join with
- */
-export function fullJoin<
-  K,
-  V1 extends (T extends KeyValue<infer _KT, infer VT> ? VT : never),
-  V2,
-  T,
->(
-  other: IStreamBuilder<KeyValue<K, V2>>,
-): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {
-  return join(other, `full`) as unknown as PipedOperator<
-    T,
-    KeyValue<K, [V1 | null, V2 | null]>
-  >
-}

package/src/operators/orderBy.ts

@@ -1,9 +1,7 @@
-import { topK, topKWithIndex } from './topK.js'
 import { topKWithFractionalIndex } from './topKWithFractionalIndex.js'
-import { map } from './map.js'
-import { innerJoin } from './join.js'
 import { consolidate } from './consolidate.js'
 import type { IStreamBuilder, KeyValue } from '../types.js'
+import type { SetSizeCallback } from './topKWithFractionalIndex.js'
 
 export interface OrderByOptions<Ve> {
   comparator?: (a: Ve, b: Ve) => number
@@ -12,133 +10,25 @@ export interface OrderByOptions<Ve> {
 }
 
 type OrderByWithFractionalIndexOptions<Ve> = OrderByOptions<Ve> & {
-  setSizeCallback?: (getSize: () => number) => void
+  setSizeCallback?: SetSizeCallback
   setWindowFn?: (
     windowFn: (options: { offset?: number; limit?: number }) => void,
   ) => void
 }
 
-/**
- * Orders the elements and limits the number of results, with optional offset
- * This requires a keyed stream, and uses the `topK` operator to order all the elements.
- *
- * @param valueExtractor - A function that extracts the value to order by from the element
- * @param options - An optional object containing comparator, limit and offset properties
- * @returns A piped operator that orders the elements and limits the number of results
- */
-export function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(
-  valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never,
-  ) => Ve,
-  options?: OrderByOptions<Ve>,
-) {
-  const limit = options?.limit ?? Infinity
-  const offset = options?.offset ?? 0
-  const comparator =
-    options?.comparator ??
-    ((a, b) => {
-      // Default to JS like ordering
-      if (a === b) return 0
-      if (a < b) return -1
-      return 1
-    })
-
-  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
-    type KeyType = T extends KeyValue<infer K, unknown> ? K : never
-
-    return stream.pipe(
-      map(
-        ([key, value]) =>
-          [
-            null,
-            [
-              key,
-              valueExtractor(
-                value as T extends KeyValue<unknown, infer V> ? V : never,
-              ),
-            ],
-          ] as KeyValue<null, [KeyType, Ve]>,
-      ),
-      topK((a, b) => comparator(a[1], b[1]), { limit, offset }),
-      map(([_, [key]]) => [key, null] as KeyValue<KeyType, null>),
-      innerJoin(stream),
-      map(([key, value]) => {
-        return [key, value[1]] as T
-      }),
-      consolidate(),
-    )
-  }
-}
-
 /**
  * Orders the elements and limits the number of results, with optional offset and
- * annotates the value with the index.
- * This requires a keyed stream, and uses the `topKWithIndex` operator to order all the elements.
+ * annotates the value with a fractional index.
+ * This requires a keyed stream, and uses the `topKWithFractionalIndex` operator to order all the elements.
  *
  * @param valueExtractor - A function that extracts the value to order by from the element
  * @param options - An optional object containing comparator, limit and offset properties
  * @returns A piped operator that orders the elements and limits the number of results
  */
-export function orderByWithIndex<
-  T extends KeyValue<unknown, unknown>,
-  Ve = unknown,
->(
-  valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never,
-  ) => Ve,
-  options?: OrderByOptions<Ve>,
-) {
-  const limit = options?.limit ?? Infinity
-  const offset = options?.offset ?? 0
-  const comparator =
-    options?.comparator ??
-    ((a, b) => {
-      // Default to JS like ordering
-      if (a === b) return 0
-      if (a < b) return -1
-      return 1
-    })
-
-  return (
-    stream: IStreamBuilder<T>,
-  ): IStreamBuilder<
-    KeyValue<
-      T extends KeyValue<infer K, unknown> ? K : never,
-      [T extends KeyValue<unknown, infer V> ? V : never, number]
-    >
-  > => {
-    type KeyType = T extends KeyValue<infer K, unknown> ? K : never
-    type ValueType = T extends KeyValue<unknown, infer V> ? V : never
-
-    return stream.pipe(
-      map(
-        ([key, value]) =>
-          [
-            null,
-            [
-              key,
-              valueExtractor(
-                value as T extends KeyValue<unknown, infer V> ? V : never,
-              ),
-            ],
-          ] as KeyValue<null, [KeyType, Ve]>,
-      ),
-      topKWithIndex((a, b) => comparator(a[1], b[1]), { limit, offset }),
-      map(([_, [[key], index]]) => [key, index] as KeyValue<KeyType, number>),
-      innerJoin(stream),
-      map(([key, [index, value]]) => {
-        return [key, [value, index]] as KeyValue<KeyType, [ValueType, number]>
-      }),
-      consolidate(),
-    )
-  }
-}
-
-export function orderByWithFractionalIndexBase<
+export function orderByWithFractionalIndex<
   T extends KeyValue<unknown, unknown>,
   Ve = unknown,
 >(
-  topKFunction: typeof topKWithFractionalIndex,
   valueExtractor: (
     value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
@@ -164,7 +54,7 @@ export function orderByWithFractionalIndexBase<
     stream: IStreamBuilder<T>,
   ): IStreamBuilder<[KeyType, [ValueType, string]]> => {
     return stream.pipe(
-      topKFunction(
+      topKWithFractionalIndex(
         (a: ValueType, b: ValueType) =>
           comparator(valueExtractor(a), valueExtractor(b)),
         {
@@ -178,28 +68,3 @@ export function orderByWithFractionalIndexBase<
     )
   }
 }
-
-/**
- * Orders the elements and limits the number of results, with optional offset and
- * annotates the value with a fractional index.
- * This requires a keyed stream, and uses the `topKWithFractionalIndex` operator to order all the elements.
- *
- * @param valueExtractor - A function that extracts the value to order by from the element
- * @param options - An optional object containing comparator, limit and offset properties
- * @returns A piped operator that orders the elements and limits the number of results
- */
-export function orderByWithFractionalIndex<
-  T extends KeyValue<unknown, unknown>,
-  Ve = unknown,
->(
-  valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never,
-  ) => Ve,
-  options?: OrderByWithFractionalIndexOptions<Ve>,
-) {
-  return orderByWithFractionalIndexBase(
-    topKWithFractionalIndex,
-    valueExtractor,
-    options,
-  )
-}

package/src/operators/reduce.ts

@@ -5,12 +5,23 @@ import { Index } from '../indexes.js'
 import type { DifferenceStreamReader } from '../graph.js'
 import type { IStreamBuilder, KeyValue } from '../types.js'
 
+/** The key identity of a Map: SameValueZero, so NaN equals NaN. */
+function sameOutput(left: unknown, right: unknown): boolean {
+  return left === right || (left !== left && right !== right)
+}
+
+/** The value a Map stores as a key: -0 becomes 0. */
+function asMapKey<T>(value: T): T {
+  return (value === 0 ? 0 : value) as T
+}
+
 /**
  * Base operator for reduction operations (version-free)
  */
 export class ReduceOperator<K, V1, V2> extends UnaryOperator<[K, V1], [K, V2]> {
-  #index = new Index<K, V1>()
-  #indexOut = new Index<K, V2>()
+  // Reduce never reads presence, so its indexes skip that bookkeeping.
+  #index: Index<K, V1>
+  #indexOut = new Index<K, V2>({ trackPresence: false })
   #f: (values: Array<[V1, number]>) => Array<[V2, number]>
 
   constructor(
@@ -18,8 +29,10 @@ export class ReduceOperator<K, V1, V2> extends UnaryOperator<[K, V1], [K, V2]> {
     inputA: DifferenceStreamReader<[K, V1]>,
     output: DifferenceStreamWriter<[K, V2]>,
     f: (values: Array<[V1, number]>) => Array<[V2, number]>,
+    options?: ReduceOptions,
   ) {
     super(id, inputA, output)
+    this.#index = new Index<K, V1>({ ...options, trackPresence: false })
     this.#f = f
   }
 
@@ -41,6 +54,36 @@ export class ReduceOperator<K, V1, V2> extends UnaryOperator<[K, V1], [K, V2]> {
       const currOut = this.#indexOut.get(key)
       const out = this.#f(curr)
 
+      // Most keys have at most one output before and after. Compare the two
+      // directly, by the SameValueZero identity the maps below use.
+      if (out.length <= 1 && currOut.length <= 1) {
+        // Earlier outputs were stored as Map keys, so only the new one needs it.
+        const before = currOut[0]
+        const after = out[0]
+        const value = after === undefined ? undefined : asMapKey(after[0])
+        if (
+          before !== undefined &&
+          after !== undefined &&
+          sameOutput(before[0], value)
+        ) {
+          const delta = after[1] - before[1]
+          if (delta !== 0) {
+            result.push([[key, before[0]], delta])
+            this.#indexOut.addValue(key, [before[0], delta])
+          }
+          continue
+        }
+        if (before !== undefined) {
+          result.push([[key, before[0]], -before[1]])
+          this.#indexOut.addValue(key, [before[0], -before[1]])
+        }
+        if (after !== undefined && after[1] !== 0) {
+          result.push([[key, value as V2], after[1]])
+          this.#indexOut.addValue(key, [value as V2, after[1]])
+        }
+        continue
+      }
+
       // Create maps for current and previous outputs using values directly as keys
       const newOutputMap = new Map<V2, number>()
       const oldOutputMap = new Map<V2, number>()
@@ -97,6 +140,16 @@ export class ReduceOperator<K, V1, V2> extends UnaryOperator<[K, V1], [K, V2]> {
   }
 }
 
+/** @internal groupBy's option; its producer must keep the identity exact. */
+export type ReduceOptions = {
+  /**
+   * Input values are `[identity, value]` with a string or number identity
+   * that determines the value: two inputs under one key with an equal
+   * identity are equal. They merge without a structural hash.
+   */
+  prefixIdentity?: boolean
+}
+
 /**
  * Reduces the elements in the stream by key (version-free)
  */
@@ -105,7 +158,10 @@ export function reduce<
   V1Type extends (T extends KeyValue<KType, infer V> ? V : never),
   R,
   T,
->(f: (values: Array<[V1Type, number]>) => Array<[R, number]>) {
+>(
+  f: (values: Array<[V1Type, number]>) => Array<[R, number]>,
+  options?: ReduceOptions,
+) {
   return (stream: IStreamBuilder<T>): IStreamBuilder<KeyValue<KType, R>> => {
     const output = new StreamBuilder<KeyValue<KType, R>>(
       stream.graph,
@@ -116,6 +172,7 @@ export function reduce<
       stream.connectReader() as DifferenceStreamReader<KeyValue<KType, V1Type>>,
       output.writer,
       f,
+      options,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/topKArray.ts

@@ -62,6 +62,11 @@ export type TopKMoveChanges<V> = {
  */
 export interface TopK<V> {
   size: number
+  /**
+   * The number of leading window values that satisfy a predicate that holds
+   * for a prefix of the window order. Optional; a caller falls back to size.
+   */
+  countLeadingInWindow?: (predicate: (value: V) => boolean) => number
   insert: (value: V) => TopKChanges<V>
   delete: (value: V) => TopKChanges<V>
 }
@@ -95,6 +100,16 @@ export class TopKArray<V> implements TopK<V> {
     return Math.max(0, Math.min(limit, available))
   }
 
+  countLeadingInWindow(predicate: (value: V) => boolean): number {
+    let count = 0
+    const end = this.#topKStart + this.size
+    for (let index = this.#topKStart; index < end; index++) {
+      if (!predicate(getValue(this.#sortedValues[index]!))) break
+      count++
+    }
+    return count
+  }
+
   /**
    * Moves the topK window
    */

package/src/operators/topKState.ts

@@ -68,6 +68,13 @@ export class TopKState<K extends string | number, T> {
     return this.#topK.size
   }
 
+  countLeadingInWindow(predicate: (value: T) => boolean): number {
+    return (
+      this.#topK.countLeadingInWindow?.(([, value]) => predicate(value)) ??
+      this.#topK.size
+    )
+  }
+
   get isEmpty(): boolean {
     return this.#multiplicities.size === 0 && this.#topK.size === 0
   }

package/src/operators/topKWithFractionalIndex.ts

@@ -8,19 +8,27 @@ import {
   topKBatch,
 } from './topKState.js'
 import { TopKArray, createKeyedComparator } from './topKArray.js'
-import type { IndexedValue, TopK } from './topKArray.js'
+import type { IndexedValue } from './topKArray.js'
 import type { DifferenceStreamReader } from '../graph.js'
 import type { IStreamBuilder, PipedOperator } from '../types.js'
 
 export interface TopKWithFractionalIndexOptions {
   limit?: number
   offset?: number
-  setSizeCallback?: (getSize: () => number) => void
+  setSizeCallback?: SetSizeCallback
   setWindowFn?: (
     windowFn: (options: { offset?: number; limit?: number }) => void,
   ) => void
 }
 
+/**
+ * Receives the window size. Given a predicate that holds for a prefix of the
+ * window order, the getter counts only the leading values that satisfy it.
+ */
+export type SetSizeCallback = (
+  getSize: (counts?: (value: unknown) => boolean) => number,
+) => void
+
 /**
  * Operator for fractional indexed topK operations
  * This operator maintains fractional indices for sorted elements
@@ -42,24 +50,15 @@ export class TopKWithFractionalIndexOperator<
     super(id, inputA, output)
     const limit = options.limit ?? Infinity
     const offset = options.offset ?? 0
-    const topK = this.createTopK(
-      offset,
-      limit,
-      createKeyedComparator(comparator),
+    this.#state = new TopKState(
+      new TopKArray(offset, limit, createKeyedComparator(comparator)),
+    )
+    options.setSizeCallback?.((counts) =>
+      counts ? this.#state.countLeadingInWindow(counts) : this.#state.size,
     )
-    this.#state = new TopKState(topK)
-    options.setSizeCallback?.(() => this.#state.size)
     options.setWindowFn?.(this.moveTopK.bind(this))
   }
 
-  protected createTopK(
-    offset: number,
-    limit: number,
-    comparator: (a: [K, T], b: [K, T]) => number,
-  ): TopK<[K, T]> {
-    return new TopKArray(offset, limit, comparator)
-  }
-
   /**
    * Moves the topK window based on the provided offset and limit.
    * Any changes to the topK are sent to the output.

package/src/utils.ts

@@ -1,18 +1,5 @@
 import { isTemporal } from './hashing/temporal.js'
 
-/**
- * Simple assertion function for runtime checks.
- * Throws an error if the condition is false.
- */
-export function assert(
-  condition: unknown,
-  message?: string,
-): asserts condition {
-  if (!condition) {
-    throw new Error(message || `Assertion failed`)
-  }
-}
-
 // 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
@@ -70,23 +57,6 @@ export function getStringId(
   return `${type}_${String(value)}`
 }
 
-export function* concatIterable<T>(
-  ...iterables: Array<Iterable<T>>
-): Iterable<T> {
-  for (const iterable of iterables) {
-    yield* iterable
-  }
-}
-
-export function* mapIterable<T, U>(
-  it: Iterable<T>,
-  fn: (t: T) => U,
-): Iterable<U> {
-  for (const t of it) {
-    yield fn(t)
-  }
-}
-
 export type HRange = [number, number] // half-open [start, end[ i.e. end is exclusive
 
 /**

package/dist/cjs/operators/count.cjs

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const graph = require("../graph.cjs");
-const d2 = require("../d2.cjs");
-const reduce = require("./reduce.cjs");
-class CountOperator extends reduce.ReduceOperator {
-  constructor(id, inputA, output) {
-    const countInner = (vals) => {
-      let totalCount = 0;
-      for (const [_, diff] of vals) {
-        totalCount += diff;
-      }
-      return [[totalCount, 1]];
-    };
-    super(id, inputA, output, countInner);
-  }
-}
-function count() {
-  return (stream) => {
-    const output = new d2.StreamBuilder(
-      stream.graph,
-      new graph.DifferenceStreamWriter()
-    );
-    const operator = new CountOperator(
-      stream.graph.getNextOperatorId(),
-      stream.connectReader(),
-      output.writer
-    );
-    stream.graph.addOperator(operator);
-    return output;
-  };
-}
-exports.CountOperator = CountOperator;
-exports.count = count;
-//# sourceMappingURL=count.cjs.map

package/dist/cjs/operators/count.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"count.cjs","sources":["../../../src/operators/count.ts"],"sourcesContent":["import { DifferenceStreamWriter } from '../graph.js'\nimport { StreamBuilder } from '../d2.js'\nimport { ReduceOperator } from './reduce.js'\nimport type { DifferenceStreamReader } from '../graph.js'\nimport type { IStreamBuilder, KeyValue } from '../types.js'\n\n/**\n * Operator that counts elements by key (version-free)\n */\nexport class CountOperator<K, V> extends ReduceOperator<K, V, number> {\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<[K, V]>,\n    output: DifferenceStreamWriter<[K, number]>,\n  ) {\n    const countInner = (vals: Array<[V, number]>): Array<[number, number]> => {\n      let totalCount = 0\n      for (const [_, diff] of vals) {\n        totalCount += diff\n      }\n      return [[totalCount, 1]]\n    }\n\n    super(id, inputA, output, countInner)\n  }\n}\n\n/**\n * Counts the number of elements by key (version-free)\n */\nexport function count<\n  KType extends (T extends KeyValue<infer K, infer _V> ? K : never),\n  VType extends (T extends KeyValue<KType, infer V> ? V : never),\n  T,\n>() {\n  return (\n    stream: IStreamBuilder<T>,\n  ): IStreamBuilder<KeyValue<KType, number>> => {\n    const output = new StreamBuilder<KeyValue<KType, number>>(\n      stream.graph,\n      new DifferenceStreamWriter<KeyValue<KType, number>>(),\n    )\n    const operator = new CountOperator<KType, VType>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader() as DifferenceStreamReader<KeyValue<KType, VType>>,\n      output.writer,\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":["ReduceOperator","StreamBuilder","DifferenceStreamWriter"],"mappings":";;;;;AASO,MAAM,sBAA4BA,OAAAA,eAA6B;AAAA,EACpE,YACE,IACA,QACA,QACA;AACA,UAAM,aAAa,CAAC,SAAsD;AACxE,UAAI,aAAa;AACjB,iBAAW,CAAC,GAAG,IAAI,KAAK,MAAM;AAC5B,sBAAc;AAAA,MAChB;AACA,aAAO,CAAC,CAAC,YAAY,CAAC,CAAC;AAAA,IACzB;AAEA,UAAM,IAAI,QAAQ,QAAQ,UAAU;AAAA,EACtC;AACF;AAKO,SAAS,QAIZ;AACF,SAAO,CACL,WAC4C;AAC5C,UAAM,SAAS,IAAIC,GAAAA;AAAAA,MACjB,OAAO;AAAA,MACP,IAAIC,MAAAA,uBAAA;AAAA,IAAgD;AAEtD,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,OAAO;AAAA,IAAA;AAET,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;;;"}

package/dist/cjs/operators/count.d.cts

@@ -1,19 +0,0 @@
-import { DifferenceStreamWriter, DifferenceStreamReader } from "../graph.cjs";
-import { ReduceOperator } from "./reduce.cjs";
-import { IStreamBuilder, KeyValue } from "../types.cjs";
-/**
- * Operator that counts elements by key (version-free)
- */
-export declare class CountOperator<K, V> extends ReduceOperator<K, V, number> {
-    constructor(id: number, inputA: DifferenceStreamReader<[
-        K,
-        V
-    ]>, output: DifferenceStreamWriter<[
-        K,
-        number
-    ]>);
-}
-/**
- * Counts the number of elements by key (version-free)
- */
-export declare function count<KType extends (T extends KeyValue<infer K, infer _V> ? K : never), VType extends (T extends KeyValue<KType, infer V> ? V : never), T>(): (stream: IStreamBuilder<T>) => IStreamBuilder<KeyValue<KType, number>>;

package/dist/cjs/operators/debug.cjs

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const graph = require("../graph.cjs");
-const d2 = require("../d2.cjs");
-class DebugOperator extends graph.UnaryOperator {
-  #name;
-  #indent;
-  constructor(id, inputA, output, name, indent = false) {
-    super(id, inputA, output);
-    this.#name = name;
-    this.#indent = indent;
-  }
-  run() {
-    for (const message of this.inputMessages()) {
-      console.log(`debug ${this.#name} data: ${message.toString(this.#indent)}`);
-      this.output.sendData(message);
-    }
-  }
-}
-function debug(name, indent = false) {
-  return (stream) => {
-    const output = new d2.StreamBuilder(
-      stream.graph,
-      new graph.DifferenceStreamWriter()
-    );
-    const operator = new DebugOperator(
-      stream.graph.getNextOperatorId(),
-      stream.connectReader(),
-      output.writer,
-      name,
-      indent
-    );
-    stream.graph.addOperator(operator);
-    return output;
-  };
-}
-exports.DebugOperator = DebugOperator;
-exports.debug = debug;
-//# sourceMappingURL=debug.cjs.map

package/dist/cjs/operators/debug.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.cjs","sources":["../../../src/operators/debug.ts"],"sourcesContent":["import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'\nimport { StreamBuilder } from '../d2.js'\nimport type { IStreamBuilder, PipedOperator } from '../types.js'\nimport type { DifferenceStreamReader } from '../graph.js'\n\n/**\n * Operator that logs debug information about the stream\n */\nexport class DebugOperator<T> extends UnaryOperator<T> {\n  #name: string\n  #indent: boolean\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<T>,\n    output: DifferenceStreamWriter<T>,\n    name: string,\n    indent: boolean = false,\n  ) {\n    super(id, inputA, output)\n    this.#name = name\n    this.#indent = indent\n  }\n\n  run(): void {\n    for (const message of this.inputMessages()) {\n      console.log(`debug ${this.#name} data: ${message.toString(this.#indent)}`)\n      this.output.sendData(message)\n    }\n  }\n}\n\n/**\n * Logs debug information about the stream using console.log\n * @param name - The name to prefix debug messages with\n * @param indent - Whether to indent the debug output\n */\nexport function debug<T>(\n  name: string,\n  indent: boolean = false,\n): PipedOperator<T, T> {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const output = new StreamBuilder<T>(\n      stream.graph,\n      new DifferenceStreamWriter<T>(),\n    )\n    const operator = new DebugOperator<T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      output.writer,\n      name,\n      indent,\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":["UnaryOperator","StreamBuilder","DifferenceStreamWriter"],"mappings":";;;;AAQO,MAAM,sBAAyBA,MAAAA,cAAiB;AAAA,EACrD;AAAA,EACA;AAAA,EAEA,YACE,IACA,QACA,QACA,MACA,SAAkB,OAClB;AACA,UAAM,IAAI,QAAQ,MAAM;AACxB,SAAK,QAAQ;AACb,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,MAAY;AACV,eAAW,WAAW,KAAK,iBAAiB;AAC1C,cAAQ,IAAI,SAAS,KAAK,KAAK,UAAU,QAAQ,SAAS,KAAK,OAAO,CAAC,EAAE;AACzE,WAAK,OAAO,SAAS,OAAO;AAAA,IAC9B;AAAA,EACF;AACF;AAOO,SAAS,MACd,MACA,SAAkB,OACG;AACrB,SAAO,CAAC,WAAiD;AACvD,UAAM,SAAS,IAAIC,GAAAA;AAAAA,MACjB,OAAO;AAAA,MACP,IAAIC,MAAAA,uBAAA;AAAA,IAA0B;AAEhC,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,OAAO;AAAA,MACP;AAAA,MACA;AAAA,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;;;"}

package/dist/cjs/operators/debug.d.cts

@@ -1,16 +0,0 @@
-import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from "../graph.cjs";
-import { PipedOperator } from "../types.cjs";
-/**
- * Operator that logs debug information about the stream
- */
-export declare class DebugOperator<T> extends UnaryOperator<T> {
-    #private;
-    constructor(id: number, inputA: DifferenceStreamReader<T>, output: DifferenceStreamWriter<T>, name: string, indent?: boolean);
-    run(): void;
-}
-/**
- * Logs debug information about the stream using console.log
- * @param name - The name to prefix debug messages with
- * @param indent - Whether to indent the debug output
- */
-export declare function debug<T>(name: string, indent?: boolean): PipedOperator<T, T>;

package/dist/cjs/operators/filterBy.cjs

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const map = require("./map.cjs");
-const join = require("./join.cjs");
-const consolidate = require("./consolidate.cjs");
-function filterBy(other) {
-  return (stream) => {
-    const otherKeys = other.pipe(
-      map.map(([key, _]) => [key, null])
-    );
-    return stream.pipe(
-      join.innerJoin(otherKeys),
-      map.map(([key, [value, _]]) => [key, value]),
-      consolidate.consolidate()
-    );
-  };
-}
-exports.filterBy = filterBy;
-//# sourceMappingURL=filterBy.cjs.map