@tanstack/db-ivm 0.0.0 → 0.1.1

package/dist/cjs/multiset.cjs

@@ -0,0 +1,173 @@
+"use strict";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _inner, _MultiSet_instances, consolidateKeyed_fn, consolidateUnkeyed_fn;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("./utils.cjs");
+const _MultiSet = class _MultiSet {
+  constructor(data = []) {
+    __privateAdd(this, _MultiSet_instances);
+    __privateAdd(this, _inner);
+    __privateSet(this, _inner, data);
+  }
+  toString(indent = false) {
+    return `MultiSet(${JSON.stringify(__privateGet(this, _inner), null, indent ? 2 : void 0)})`;
+  }
+  toJSON() {
+    return JSON.stringify(Array.from(this.getInner()));
+  }
+  static fromJSON(json) {
+    return new _MultiSet(JSON.parse(json));
+  }
+  /**
+   * Apply a function to all records in the collection.
+   */
+  map(f) {
+    return new _MultiSet(
+      __privateGet(this, _inner).map(([data, multiplicity]) => [f(data), multiplicity])
+    );
+  }
+  /**
+   * Filter out records for which a function f(record) evaluates to False.
+   */
+  filter(f) {
+    return new _MultiSet(__privateGet(this, _inner).filter(([data, _]) => f(data)));
+  }
+  /**
+   * Negate all multiplicities in the collection.
+   */
+  negate() {
+    return new _MultiSet(
+      __privateGet(this, _inner).map(([data, multiplicity]) => [data, -multiplicity])
+    );
+  }
+  /**
+   * Concatenate two collections together.
+   */
+  concat(other) {
+    const out = [];
+    utils.chunkedArrayPush(out, __privateGet(this, _inner));
+    utils.chunkedArrayPush(out, other.getInner());
+    return new _MultiSet(out);
+  }
+  /**
+   * Produce as output a collection that is logically equivalent to the input
+   * but which combines identical instances of the same record into one
+   * (record, multiplicity) pair.
+   */
+  consolidate() {
+    var _a;
+    if (__privateGet(this, _inner).length > 0) {
+      const firstItem = (_a = __privateGet(this, _inner)[0]) == null ? void 0 : _a[0];
+      if (Array.isArray(firstItem) && firstItem.length === 2) {
+        return __privateMethod(this, _MultiSet_instances, consolidateKeyed_fn).call(this);
+      }
+    }
+    return __privateMethod(this, _MultiSet_instances, consolidateUnkeyed_fn).call(this);
+  }
+  extend(other) {
+    const otherArray = other instanceof _MultiSet ? other.getInner() : other;
+    utils.chunkedArrayPush(__privateGet(this, _inner), otherArray);
+  }
+  getInner() {
+    return __privateGet(this, _inner);
+  }
+};
+_inner = new WeakMap();
+_MultiSet_instances = new WeakSet();
+/**
+ * Private method for consolidating keyed multisets where keys are strings/numbers
+ * and values are compared by reference equality.
+ *
+ * This method provides significant performance improvements over the hash-based approach
+ * by using WeakMap for object reference tracking and avoiding expensive serialization.
+ *
+ * Special handling for join operations: When values are tuples of length 2 (common in joins),
+ * we unpack them and compare each element individually to maintain proper equality semantics.
+ */
+consolidateKeyed_fn = function() {
+  const consolidated = /* @__PURE__ */ new Map();
+  const values = /* @__PURE__ */ new Map();
+  const getTupleId = (tuple) => {
+    if (tuple.length !== 2) {
+      throw new Error(`Expected tuple of length 2`);
+    }
+    const [first, second] = tuple;
+    return `${utils.globalObjectIdGenerator.getStringId(first)}|${utils.globalObjectIdGenerator.getStringId(second)}`;
+  };
+  for (const [data, multiplicity] of __privateGet(this, _inner)) {
+    if (!Array.isArray(data) || data.length !== 2) {
+      return __privateMethod(this, _MultiSet_instances, consolidateUnkeyed_fn).call(this);
+    }
+    const [key, value] = data;
+    if (typeof key !== `string` && typeof key !== `number`) {
+      return __privateMethod(this, _MultiSet_instances, consolidateUnkeyed_fn).call(this);
+    }
+    let valueId;
+    if (Array.isArray(value) && value.length === 2) {
+      valueId = getTupleId(value);
+    } else {
+      valueId = utils.globalObjectIdGenerator.getStringId(value);
+    }
+    const compositeKey = key + `|` + valueId;
+    consolidated.set(
+      compositeKey,
+      (consolidated.get(compositeKey) || 0) + multiplicity
+    );
+    if (!values.has(compositeKey)) {
+      values.set(compositeKey, data);
+    }
+  }
+  const result = [];
+  for (const [compositeKey, multiplicity] of consolidated) {
+    if (multiplicity !== 0) {
+      result.push([values.get(compositeKey), multiplicity]);
+    }
+  }
+  return new _MultiSet(result);
+};
+/**
+ * Private method for consolidating unkeyed multisets using the original approach.
+ */
+consolidateUnkeyed_fn = function() {
+  const consolidated = new utils.DefaultMap(() => 0);
+  const values = /* @__PURE__ */ new Map();
+  let hasString = false;
+  let hasNumber = false;
+  let hasOther = false;
+  for (const [data, _] of __privateGet(this, _inner)) {
+    if (typeof data === `string`) {
+      hasString = true;
+    } else if (typeof data === `number`) {
+      hasNumber = true;
+    } else {
+      hasOther = true;
+      break;
+    }
+  }
+  const requireJson = hasOther || hasString && hasNumber;
+  for (const [data, multiplicity] of __privateGet(this, _inner)) {
+    const key = requireJson ? utils.hash(data) : data;
+    if (requireJson && !values.has(key)) {
+      values.set(key, data);
+    }
+    consolidated.update(key, (count) => count + multiplicity);
+  }
+  const result = [];
+  for (const [key, multiplicity] of consolidated.entries()) {
+    if (multiplicity !== 0) {
+      const parsedKey = requireJson ? values.get(key) : key;
+      result.push([parsedKey, multiplicity]);
+    }
+  }
+  return new _MultiSet(result);
+};
+let MultiSet = _MultiSet;
+exports.MultiSet = MultiSet;
+//# sourceMappingURL=multiset.cjs.map

package/dist/cjs/multiset.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiset.cjs","sources":["../../src/multiset.ts"],"sourcesContent":["import {\n  DefaultMap,\n  chunkedArrayPush,\n  globalObjectIdGenerator,\n  hash,\n} from \"./utils.js\"\n\nexport type MultiSetArray<T> = Array<[T, number]>\nexport type KeyedData<T> = [key: string, value: T]\n\n/**\n * A multiset of data.\n */\nexport class MultiSet<T> {\n  #inner: MultiSetArray<T>\n\n  constructor(data: MultiSetArray<T> = []) {\n    this.#inner = data\n  }\n\n  toString(indent = false): string {\n    return `MultiSet(${JSON.stringify(this.#inner, null, indent ? 2 : undefined)})`\n  }\n\n  toJSON(): string {\n    return JSON.stringify(Array.from(this.getInner()))\n  }\n\n  static fromJSON<U>(json: string): MultiSet<U> {\n    return new MultiSet(JSON.parse(json))\n  }\n\n  /**\n   * Apply a function to all records in the collection.\n   */\n  map<U>(f: (data: T) => U): MultiSet<U> {\n    return new MultiSet(\n      this.#inner.map(([data, multiplicity]) => [f(data), multiplicity])\n    )\n  }\n\n  /**\n   * Filter out records for which a function f(record) evaluates to False.\n   */\n  filter(f: (data: T) => boolean): MultiSet<T> {\n    return new MultiSet(this.#inner.filter(([data, _]) => f(data)))\n  }\n\n  /**\n   * Negate all multiplicities in the collection.\n   */\n  negate(): MultiSet<T> {\n    return new MultiSet(\n      this.#inner.map(([data, multiplicity]) => [data, -multiplicity])\n    )\n  }\n\n  /**\n   * Concatenate two collections together.\n   */\n  concat(other: MultiSet<T>): MultiSet<T> {\n    const out: MultiSetArray<T> = []\n    chunkedArrayPush(out, this.#inner)\n    chunkedArrayPush(out, other.getInner())\n    return new MultiSet(out)\n  }\n\n  /**\n   * Produce as output a collection that is logically equivalent to the input\n   * but which combines identical instances of the same record into one\n   * (record, multiplicity) pair.\n   */\n  consolidate(): MultiSet<T> {\n    // Check if this looks like a keyed multiset (first item is a tuple of length 2)\n    if (this.#inner.length > 0) {\n      const firstItem = this.#inner[0]?.[0]\n      if (Array.isArray(firstItem) && firstItem.length === 2) {\n        return this.#consolidateKeyed()\n      }\n    }\n\n    // Fall back to original method for unkeyed data\n    return this.#consolidateUnkeyed()\n  }\n\n  /**\n   * Private method for consolidating keyed multisets where keys are strings/numbers\n   * and values are compared by reference equality.\n   *\n   * This method provides significant performance improvements over the hash-based approach\n   * by using WeakMap for object reference tracking and avoiding expensive serialization.\n   *\n   * Special handling for join operations: When values are tuples of length 2 (common in joins),\n   * we unpack them and compare each element individually to maintain proper equality semantics.\n   */\n  #consolidateKeyed(): MultiSet<T> {\n    const consolidated = new Map<string, number>()\n    const values = new Map<string, T>()\n\n    // Use global object ID generator for consistent reference equality\n\n    /**\n     * Special handler for tuples (arrays of length 2) commonly produced by join operations.\n     * Unpacks the tuple and generates an ID based on both elements to ensure proper\n     * consolidation of join results like ['A', null] and [null, 'X'].\n     */\n    const getTupleId = (tuple: Array<any>): string => {\n      if (tuple.length !== 2) {\n        throw new Error(`Expected tuple of length 2`)\n      }\n      const [first, second] = tuple\n      return `${globalObjectIdGenerator.getStringId(first)}|${globalObjectIdGenerator.getStringId(second)}`\n    }\n\n    // Process each item in the multiset\n    for (const [data, multiplicity] of this.#inner) {\n      // Verify this is still a keyed item (should be [key, value] pair)\n      if (!Array.isArray(data) || data.length !== 2) {\n        // Found non-keyed item, fall back to unkeyed consolidation\n        return this.#consolidateUnkeyed()\n      }\n\n      const [key, value] = data\n\n      // Verify key is string or number as expected for keyed multisets\n      if (typeof key !== `string` && typeof key !== `number`) {\n        // Found non-string/number key, fall back to unkeyed consolidation\n        return this.#consolidateUnkeyed()\n      }\n\n      // Generate value ID with special handling for join tuples\n      let valueId: string\n      if (Array.isArray(value) && value.length === 2) {\n        // Special case: value is a tuple from join operations\n        valueId = getTupleId(value)\n      } else {\n        // Regular case: use reference/value equality\n        valueId = globalObjectIdGenerator.getStringId(value)\n      }\n\n      // Create composite key and consolidate\n      const compositeKey = key + `|` + valueId\n      consolidated.set(\n        compositeKey,\n        (consolidated.get(compositeKey) || 0) + multiplicity\n      )\n\n      // Store the original data for the first occurrence\n      if (!values.has(compositeKey)) {\n        values.set(compositeKey, data as T)\n      }\n    }\n\n    // Build result array, filtering out zero multiplicities\n    const result: MultiSetArray<T> = []\n    for (const [compositeKey, multiplicity] of consolidated) {\n      if (multiplicity !== 0) {\n        result.push([values.get(compositeKey)!, multiplicity])\n      }\n    }\n\n    return new MultiSet(result)\n  }\n\n  /**\n   * Private method for consolidating unkeyed multisets using the original approach.\n   */\n  #consolidateUnkeyed(): MultiSet<T> {\n    const consolidated = new DefaultMap<string | number, number>(() => 0)\n    const values = new Map<string, any>()\n\n    let hasString = false\n    let hasNumber = false\n    let hasOther = false\n    for (const [data, _] of this.#inner) {\n      if (typeof data === `string`) {\n        hasString = true\n      } else if (typeof data === `number`) {\n        hasNumber = true\n      } else {\n        hasOther = true\n        break\n      }\n    }\n\n    const requireJson = hasOther || (hasString && hasNumber)\n\n    for (const [data, multiplicity] of this.#inner) {\n      const key = requireJson ? hash(data) : (data as string | number)\n      if (requireJson && !values.has(key as string)) {\n        values.set(key as string, data)\n      }\n      consolidated.update(key, (count) => count + multiplicity)\n    }\n\n    const result: MultiSetArray<T> = []\n    for (const [key, multiplicity] of consolidated.entries()) {\n      if (multiplicity !== 0) {\n        const parsedKey = requireJson ? values.get(key as string) : key\n        result.push([parsedKey as T, multiplicity])\n      }\n    }\n\n    return new MultiSet(result)\n  }\n\n  extend(other: MultiSet<T> | MultiSetArray<T>): void {\n    const otherArray = other instanceof MultiSet ? other.getInner() : other\n    chunkedArrayPush(this.#inner, otherArray)\n  }\n\n  getInner(): MultiSetArray<T> {\n    return this.#inner\n  }\n}\n"],"names":["chunkedArrayPush","globalObjectIdGenerator","DefaultMap","hash"],"mappings":"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"}

package/dist/cjs/multiset.d.cts

@@ -0,0 +1,36 @@
+export type MultiSetArray<T> = Array<[T, number]>;
+export type KeyedData<T> = [key: string, value: T];
+/**
+ * A multiset of data.
+ */
+export declare class MultiSet<T> {
+    #private;
+    constructor(data?: MultiSetArray<T>);
+    toString(indent?: boolean): string;
+    toJSON(): string;
+    static fromJSON<U>(json: string): MultiSet<U>;
+    /**
+     * Apply a function to all records in the collection.
+     */
+    map<U>(f: (data: T) => U): MultiSet<U>;
+    /**
+     * Filter out records for which a function f(record) evaluates to False.
+     */
+    filter(f: (data: T) => boolean): MultiSet<T>;
+    /**
+     * Negate all multiplicities in the collection.
+     */
+    negate(): MultiSet<T>;
+    /**
+     * Concatenate two collections together.
+     */
+    concat(other: MultiSet<T>): MultiSet<T>;
+    /**
+     * Produce as output a collection that is logically equivalent to the input
+     * but which combines identical instances of the same record into one
+     * (record, multiplicity) pair.
+     */
+    consolidate(): MultiSet<T>;
+    extend(other: MultiSet<T> | MultiSetArray<T>): void;
+    getInner(): MultiSetArray<T>;
+}

package/dist/cjs/operators/concat.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const graph = require("../graph.cjs");
+const d2 = require("../d2.cjs");
+class ConcatOperator extends graph.BinaryOperator {
+  run() {
+    for (const message of this.inputAMessages()) {
+      this.output.sendData(message);
+    }
+    for (const message of this.inputBMessages()) {
+      this.output.sendData(message);
+    }
+  }
+}
+function concat(other) {
+  return (stream) => {
+    if (stream.graph !== other.graph) {
+      throw new Error(`Cannot concat streams from different graphs`);
+    }
+    const output = new d2.StreamBuilder(
+      stream.graph,
+      new graph.DifferenceStreamWriter()
+    );
+    const operator = new ConcatOperator(
+      stream.graph.getNextOperatorId(),
+      stream.connectReader(),
+      other.connectReader(),
+      output.writer
+    );
+    stream.graph.addOperator(operator);
+    stream.graph.addStream(output.connectReader());
+    return output;
+  };
+}
+exports.ConcatOperator = ConcatOperator;
+exports.concat = concat;
+//# sourceMappingURL=concat.cjs.map

package/dist/cjs/operators/concat.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.cjs","sources":["../../../src/operators/concat.ts"],"sourcesContent":["import { BinaryOperator, DifferenceStreamWriter } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport type { IStreamBuilder, PipedOperator } from \"../types.js\"\n\n/**\n * Operator that concatenates two input streams\n */\nexport class ConcatOperator<T, T2> extends BinaryOperator<T | T2> {\n  run(): void {\n    for (const message of this.inputAMessages()) {\n      this.output.sendData(message)\n    }\n\n    for (const message of this.inputBMessages()) {\n      this.output.sendData(message)\n    }\n  }\n}\n\n/**\n * Concatenates two input streams\n * @param other - The other stream to concatenate\n */\nexport function concat<T, T2>(\n  other: IStreamBuilder<T2>\n): PipedOperator<T, T | T2> {\n  return (stream: IStreamBuilder<T | T2>): IStreamBuilder<T | T2> => {\n    if (stream.graph !== other.graph) {\n      throw new Error(`Cannot concat streams from different graphs`)\n    }\n    const output = new StreamBuilder<T | T2>(\n      stream.graph,\n      new DifferenceStreamWriter<T | T2>()\n    )\n    const operator = new ConcatOperator<T, T2>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      other.connectReader(),\n      output.writer\n    )\n    stream.graph.addOperator(operator)\n    stream.graph.addStream(output.connectReader())\n    return output\n  }\n}\n"],"names":["BinaryOperator","StreamBuilder","DifferenceStreamWriter"],"mappings":";;;;AAOO,MAAM,uBAA8BA,MAAAA,eAAuB;AAAA,EAChE,MAAY;AACV,eAAW,WAAW,KAAK,kBAAkB;AAC3C,WAAK,OAAO,SAAS,OAAO;AAAA,IAC9B;AAEA,eAAW,WAAW,KAAK,kBAAkB;AAC3C,WAAK,OAAO,SAAS,OAAO;AAAA,IAC9B;AAAA,EACF;AACF;AAMO,SAAS,OACd,OAC0B;AAC1B,SAAO,CAAC,WAA2D;AACjE,QAAI,OAAO,UAAU,MAAM,OAAO;AAChC,YAAM,IAAI,MAAM,6CAA6C;AAAA,IAC/D;AACA,UAAM,SAAS,IAAIC,GAAAA;AAAAA,MACjB,OAAO;AAAA,MACP,IAAIC,MAAAA,uBAAA;AAAA,IAA+B;AAErC,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,MAAM,cAAA;AAAA,MACN,OAAO;AAAA,IAAA;AAET,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO,MAAM,UAAU,OAAO,cAAA,CAAe;AAC7C,WAAO;AAAA,EACT;AACF;;;"}

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

@@ -0,0 +1,13 @@
+import { BinaryOperator } from '../graph.js';
+import { IStreamBuilder, PipedOperator } from '../types.js';
+/**
+ * Operator that concatenates two input streams
+ */
+export declare class ConcatOperator<T, T2> extends BinaryOperator<T | T2> {
+    run(): void;
+}
+/**
+ * Concatenates two input streams
+ * @param other - The other stream to concatenate
+ */
+export declare function concat<T, T2>(other: IStreamBuilder<T2>): PipedOperator<T, T | T2>;

package/dist/cjs/operators/consolidate.cjs

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const graph = require("../graph.cjs");
+const d2 = require("../d2.cjs");
+const multiset = require("../multiset.cjs");
+class ConsolidateOperator extends graph.UnaryOperator {
+  run() {
+    const messages = this.inputMessages();
+    if (messages.length === 0) {
+      return;
+    }
+    const combined = new multiset.MultiSet();
+    for (const message of messages) {
+      combined.extend(message);
+    }
+    const consolidated = combined.consolidate();
+    if (consolidated.getInner().length > 0) {
+      this.output.sendData(consolidated);
+    }
+  }
+}
+function consolidate() {
+  return (stream) => {
+    const output = new d2.StreamBuilder(
+      stream.graph,
+      new graph.DifferenceStreamWriter()
+    );
+    const operator = new ConsolidateOperator(
+      stream.graph.getNextOperatorId(),
+      stream.connectReader(),
+      output.writer
+    );
+    stream.graph.addOperator(operator);
+    stream.graph.addStream(output.connectReader());
+    return output;
+  };
+}
+exports.ConsolidateOperator = ConsolidateOperator;
+exports.consolidate = consolidate;
+//# sourceMappingURL=consolidate.cjs.map

package/dist/cjs/operators/consolidate.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"consolidate.cjs","sources":["../../../src/operators/consolidate.ts"],"sourcesContent":["import { DifferenceStreamWriter, UnaryOperator } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport { MultiSet } from \"../multiset.js\"\nimport type { IStreamBuilder, PipedOperator } from \"../types.js\"\n\n/**\n * Operator that consolidates collections\n */\nexport class ConsolidateOperator<T> extends UnaryOperator<T> {\n  run(): void {\n    const messages = this.inputMessages()\n    if (messages.length === 0) {\n      return\n    }\n\n    // Combine all messages into a single MultiSet\n    const combined = new MultiSet<T>()\n    for (const message of messages) {\n      combined.extend(message)\n    }\n\n    // Consolidate the combined MultiSet\n    const consolidated = combined.consolidate()\n\n    // Only send if there are results\n    if (consolidated.getInner().length > 0) {\n      this.output.sendData(consolidated)\n    }\n  }\n}\n\n/**\n * Consolidates the elements in the stream\n */\nexport function consolidate<T>(): 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 ConsolidateOperator<T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      output.writer\n    )\n    stream.graph.addOperator(operator)\n    stream.graph.addStream(output.connectReader())\n    return output\n  }\n}\n"],"names":["UnaryOperator","MultiSet","StreamBuilder","DifferenceStreamWriter"],"mappings":";;;;;AAQO,MAAM,4BAA+BA,MAAAA,cAAiB;AAAA,EAC3D,MAAY;AACV,UAAM,WAAW,KAAK,cAAA;AACtB,QAAI,SAAS,WAAW,GAAG;AACzB;AAAA,IACF;AAGA,UAAM,WAAW,IAAIC,kBAAA;AACrB,eAAW,WAAW,UAAU;AAC9B,eAAS,OAAO,OAAO;AAAA,IACzB;AAGA,UAAM,eAAe,SAAS,YAAA;AAG9B,QAAI,aAAa,WAAW,SAAS,GAAG;AACtC,WAAK,OAAO,SAAS,YAAY;AAAA,IACnC;AAAA,EACF;AACF;AAKO,SAAS,cAAsC;AACpD,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,IAAA;AAET,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO,MAAM,UAAU,OAAO,cAAA,CAAe;AAC7C,WAAO;AAAA,EACT;AACF;;;"}

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

@@ -0,0 +1,12 @@
+import { UnaryOperator } from '../graph.js';
+import { PipedOperator } from '../types.js';
+/**
+ * Operator that consolidates collections
+ */
+export declare class ConsolidateOperator<T> extends UnaryOperator<T> {
+    run(): void;
+}
+/**
+ * Consolidates the elements in the stream
+ */
+export declare function consolidate<T>(): PipedOperator<T, T>;

package/dist/cjs/operators/count.cjs

@@ -0,0 +1,36 @@
+"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);
+    stream.graph.addStream(output.connectReader());
+    return output;
+  };
+}
+exports.CountOperator = CountOperator;
+exports.count = count;
+//# sourceMappingURL=count.cjs.map

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

@@ -0,0 +1 @@
+{"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    stream.graph.addStream(output.connectReader())\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,MAAM,UAAU,OAAO,cAAA,CAAe;AAC7C,WAAO;AAAA,EACT;AACF;;;"}

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

@@ -0,0 +1,13 @@
+import { DifferenceStreamWriter, DifferenceStreamReader } from '../graph.js';
+import { ReduceOperator } from './reduce.js';
+import { IStreamBuilder, KeyValue } from '../types.js';
+/**
+ * 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

@@ -0,0 +1,50 @@
+"use strict";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _name, _indent;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const graph = require("../graph.cjs");
+const d2 = require("../d2.cjs");
+class DebugOperator extends graph.UnaryOperator {
+  constructor(id, inputA, output, name, indent = false) {
+    super(id, inputA, output);
+    __privateAdd(this, _name);
+    __privateAdd(this, _indent);
+    __privateSet(this, _name, name);
+    __privateSet(this, _indent, indent);
+  }
+  run() {
+    for (const message of this.inputMessages()) {
+      console.log(`debug ${__privateGet(this, _name)} data: ${message.toString(__privateGet(this, _indent))}`);
+      this.output.sendData(message);
+    }
+  }
+}
+_name = new WeakMap();
+_indent = new WeakMap();
+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);
+    stream.graph.addStream(output.connectReader());
+    return output;
+  };
+}
+exports.DebugOperator = DebugOperator;
+exports.debug = debug;
+//# sourceMappingURL=debug.cjs.map

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

@@ -0,0 +1 @@
+{"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    stream.graph.addStream(output.connectReader())\n    return output\n  }\n}\n"],"names":["UnaryOperator","StreamBuilder","DifferenceStreamWriter"],"mappings":";;;;;;;;;;;;AAQO,MAAM,sBAAyBA,MAAAA,cAAiB;AAAA,EAIrD,YACE,IACA,QACA,QACA,MACA,SAAkB,OAClB;AACA,UAAM,IAAI,QAAQ,MAAM;AAV1B;AACA;AAUE,uBAAK,OAAQ;AACb,uBAAK,SAAU;AAAA,EACjB;AAAA,EAEA,MAAY;AACV,eAAW,WAAW,KAAK,iBAAiB;AAC1C,cAAQ,IAAI,SAAS,mBAAK,MAAK,UAAU,QAAQ,SAAS,mBAAK,QAAO,CAAC,EAAE;AACzE,WAAK,OAAO,SAAS,OAAO;AAAA,IAC9B;AAAA,EACF;AACF;AArBE;AACA;AA2BK,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,MAAM,UAAU,OAAO,cAAA,CAAe;AAC7C,WAAO;AAAA,EACT;AACF;;;"}

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

@@ -0,0 +1,16 @@
+import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from '../graph.js';
+import { PipedOperator } from '../types.js';
+/**
+ * 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/distinct.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _by, _values;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const graph = require("../graph.cjs");
+const d2 = require("../d2.cjs");
+const utils = require("../utils.cjs");
+const multiset = require("../multiset.cjs");
+class DistinctOperator extends graph.UnaryOperator {
+  // keeps track of the number of times each value has been seen
+  constructor(id, input, output, by = (value) => value) {
+    super(id, input, output);
+    __privateAdd(this, _by);
+    __privateAdd(this, _values);
+    __privateSet(this, _by, by);
+    __privateSet(this, _values, /* @__PURE__ */ new Map());
+  }
+  run() {
+    var _a;
+    const updatedValues = /* @__PURE__ */ new Map();
+    for (const message of this.inputMessages()) {
+      for (const [value, diff] of message.getInner()) {
+        const hashedValue = utils.hash(__privateGet(this, _by).call(this, value));
+        const oldMultiplicity = ((_a = updatedValues.get(hashedValue)) == null ? void 0 : _a[0]) ?? __privateGet(this, _values).get(hashedValue) ?? 0;
+        const newMultiplicity = oldMultiplicity + diff;
+        updatedValues.set(hashedValue, [newMultiplicity, value]);
+      }
+    }
+    const result = [];
+    for (const [
+      hashedValue,
+      [newMultiplicity, value]
+    ] of updatedValues.entries()) {
+      const oldMultiplicity = __privateGet(this, _values).get(hashedValue) ?? 0;
+      if (newMultiplicity === 0) {
+        __privateGet(this, _values).delete(hashedValue);
+      } else {
+        __privateGet(this, _values).set(hashedValue, newMultiplicity);
+      }
+      if (oldMultiplicity <= 0 && newMultiplicity > 0) {
+        result.push([value, 1]);
+      } else if (oldMultiplicity > 0 && newMultiplicity <= 0) {
+        result.push([value, -1]);
+      }
+    }
+    if (result.length > 0) {
+      this.output.sendData(new multiset.MultiSet(result));
+    }
+  }
+}
+_by = new WeakMap();
+_values = new WeakMap();
+function distinct(by = (value) => value) {
+  return (stream) => {
+    const output = new d2.StreamBuilder(
+      stream.graph,
+      new graph.DifferenceStreamWriter()
+    );
+    const operator = new DistinctOperator(
+      stream.graph.getNextOperatorId(),
+      stream.connectReader(),
+      output.writer,
+      by
+    );
+    stream.graph.addOperator(operator);
+    stream.graph.addStream(output.connectReader());
+    return output;
+  };
+}
+exports.DistinctOperator = DistinctOperator;
+exports.distinct = distinct;
+//# sourceMappingURL=distinct.cjs.map

package/dist/cjs/operators/distinct.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"distinct.cjs","sources":["../../../src/operators/distinct.ts"],"sourcesContent":["import { DifferenceStreamWriter, UnaryOperator } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport { hash } from \"../utils.js\"\nimport { MultiSet } from \"../multiset.js\"\nimport type { DifferenceStreamReader } from \"../graph.js\"\nimport type { IStreamBuilder } from \"../types.js\"\n\ntype HashedValue = string\ntype Multiplicity = number\n\n/**\n * Operator that removes duplicates\n */\nexport class DistinctOperator<T> extends UnaryOperator<T> {\n  #by: (value: T) => any\n  #values: Map<HashedValue, Multiplicity> // keeps track of the number of times each value has been seen\n\n  constructor(\n    id: number,\n    input: DifferenceStreamReader<T>,\n    output: DifferenceStreamWriter<T>,\n    by: (value: T) => any = (value: T) => value\n  ) {\n    super(id, input, output)\n    this.#by = by\n    this.#values = new Map()\n  }\n\n  run(): void {\n    const updatedValues = new Map<HashedValue, [Multiplicity, T]>()\n\n    // Compute the new multiplicity for each value\n    for (const message of this.inputMessages()) {\n      for (const [value, diff] of message.getInner()) {\n        const hashedValue = hash(this.#by(value))\n\n        const oldMultiplicity =\n          updatedValues.get(hashedValue)?.[0] ??\n          this.#values.get(hashedValue) ??\n          0\n        const newMultiplicity = oldMultiplicity + diff\n\n        updatedValues.set(hashedValue, [newMultiplicity, value])\n      }\n    }\n\n    const result: Array<[T, number]> = []\n\n    // Check which values became visible or disappeared\n    for (const [\n      hashedValue,\n      [newMultiplicity, value],\n    ] of updatedValues.entries()) {\n      const oldMultiplicity = this.#values.get(hashedValue) ?? 0\n\n      if (newMultiplicity === 0) {\n        this.#values.delete(hashedValue)\n      } else {\n        this.#values.set(hashedValue, newMultiplicity)\n      }\n\n      if (oldMultiplicity <= 0 && newMultiplicity > 0) {\n        // The value wasn't present in the stream\n        // but with this change it is now present in the stream\n        result.push([value, 1])\n      } else if (oldMultiplicity > 0 && newMultiplicity <= 0) {\n        // The value was present in the stream\n        // but with this change it is no longer present in the stream\n        result.push([value, -1])\n      }\n    }\n\n    if (result.length > 0) {\n      this.output.sendData(new MultiSet(result))\n    }\n  }\n}\n\n/**\n * Removes duplicate values\n */\nexport function distinct<T>(by: (value: T) => any = (value: T) => value) {\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 DistinctOperator<T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      output.writer,\n      by\n    )\n    stream.graph.addOperator(operator)\n    stream.graph.addStream(output.connectReader())\n    return output\n  }\n}\n"],"names":["UnaryOperator","hash","MultiSet","StreamBuilder","DifferenceStreamWriter"],"mappings":";;;;;;;;;;;;;;AAaO,MAAM,yBAA4BA,MAAAA,cAAiB;AAAA;AAAA,EAIxD,YACE,IACA,OACA,QACA,KAAwB,CAAC,UAAa,OACtC;AACA,UAAM,IAAI,OAAO,MAAM;AATzB;AACA;AASE,uBAAK,KAAM;AACX,uBAAK,6BAAc,IAAA;AAAA,EACrB;AAAA,EAEA,MAAY;;AACV,UAAM,oCAAoB,IAAA;AAG1B,eAAW,WAAW,KAAK,iBAAiB;AAC1C,iBAAW,CAAC,OAAO,IAAI,KAAK,QAAQ,YAAY;AAC9C,cAAM,cAAcC,MAAAA,KAAK,mBAAK,KAAL,WAAS,MAAM;AAExC,cAAM,oBACJ,mBAAc,IAAI,WAAW,MAA7B,mBAAiC,OACjC,mBAAK,SAAQ,IAAI,WAAW,KAC5B;AACF,cAAM,kBAAkB,kBAAkB;AAE1C,sBAAc,IAAI,aAAa,CAAC,iBAAiB,KAAK,CAAC;AAAA,MACzD;AAAA,IACF;AAEA,UAAM,SAA6B,CAAA;AAGnC,eAAW;AAAA,MACT;AAAA,MACA,CAAC,iBAAiB,KAAK;AAAA,IAAA,KACpB,cAAc,WAAW;AAC5B,YAAM,kBAAkB,mBAAK,SAAQ,IAAI,WAAW,KAAK;AAEzD,UAAI,oBAAoB,GAAG;AACzB,2BAAK,SAAQ,OAAO,WAAW;AAAA,MACjC,OAAO;AACL,2BAAK,SAAQ,IAAI,aAAa,eAAe;AAAA,MAC/C;AAEA,UAAI,mBAAmB,KAAK,kBAAkB,GAAG;AAG/C,eAAO,KAAK,CAAC,OAAO,CAAC,CAAC;AAAA,MACxB,WAAW,kBAAkB,KAAK,mBAAmB,GAAG;AAGtD,eAAO,KAAK,CAAC,OAAO,EAAE,CAAC;AAAA,MACzB;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,GAAG;AACrB,WAAK,OAAO,SAAS,IAAIC,SAAAA,SAAS,MAAM,CAAC;AAAA,IAC3C;AAAA,EACF;AACF;AA9DE;AACA;AAkEK,SAAS,SAAY,KAAwB,CAAC,UAAa,OAAO;AACvE,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,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO,MAAM,UAAU,OAAO,cAAA,CAAe;AAC7C,WAAO;AAAA,EACT;AACF;;;"}

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

@@ -0,0 +1,14 @@
+import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from '../graph.js';
+import { IStreamBuilder } from '../types.js';
+/**
+ * Operator that removes duplicates
+ */
+export declare class DistinctOperator<T> extends UnaryOperator<T> {
+    #private;
+    constructor(id: number, input: DifferenceStreamReader<T>, output: DifferenceStreamWriter<T>, by?: (value: T) => any);
+    run(): void;
+}
+/**
+ * Removes duplicate values
+ */
+export declare function distinct<T>(by?: (value: T) => any): (stream: IStreamBuilder<T>) => IStreamBuilder<T>;

package/dist/cjs/operators/filter.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _f;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const graph = require("../graph.cjs");
+const d2 = require("../d2.cjs");
+class FilterOperator extends graph.LinearUnaryOperator {
+  constructor(id, inputA, output, f) {
+    super(id, inputA, output);
+    __privateAdd(this, _f);
+    __privateSet(this, _f, f);
+  }
+  inner(collection) {
+    return collection.filter(__privateGet(this, _f));
+  }
+}
+_f = new WeakMap();
+function filter(f) {
+  return (stream) => {
+    const output = new d2.StreamBuilder(
+      stream.graph,
+      new graph.DifferenceStreamWriter()
+    );
+    const operator = new FilterOperator(
+      stream.graph.getNextOperatorId(),
+      stream.connectReader(),
+      output.writer,
+      f
+    );
+    stream.graph.addOperator(operator);
+    stream.graph.addStream(output.connectReader());
+    return output;
+  };
+}
+exports.FilterOperator = FilterOperator;
+exports.filter = filter;
+//# sourceMappingURL=filter.cjs.map

package/dist/cjs/operators/filter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.cjs","sources":["../../../src/operators/filter.ts"],"sourcesContent":["import { DifferenceStreamWriter, LinearUnaryOperator } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport type { IStreamBuilder, PipedOperator } from \"../types.js\"\nimport type { DifferenceStreamReader } from \"../graph.js\"\nimport type { MultiSet } from \"../multiset.js\"\n\n/**\n * Operator that filters elements from the input stream\n */\nexport class FilterOperator<T> extends LinearUnaryOperator<T, T> {\n  #f: (data: T) => boolean\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<T>,\n    output: DifferenceStreamWriter<T>,\n    f: (data: T) => boolean\n  ) {\n    super(id, inputA, output)\n    this.#f = f\n  }\n\n  inner(collection: MultiSet<T>): MultiSet<T> {\n    return collection.filter(this.#f)\n  }\n}\n\n/**\n * Filters elements from the input stream\n * @param f - The predicate to filter elements\n */\nexport function filter<T>(f: (data: T) => boolean): 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 FilterOperator<T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      output.writer,\n      f\n    )\n    stream.graph.addOperator(operator)\n    stream.graph.addStream(output.connectReader())\n    return output\n  }\n}\n"],"names":["LinearUnaryOperator","StreamBuilder","DifferenceStreamWriter"],"mappings":";;;;;;;;;;;;AASO,MAAM,uBAA0BA,MAAAA,oBAA0B;AAAA,EAG/D,YACE,IACA,QACA,QACA,GACA;AACA,UAAM,IAAI,QAAQ,MAAM;AAR1B;AASE,uBAAK,IAAK;AAAA,EACZ;AAAA,EAEA,MAAM,YAAsC;AAC1C,WAAO,WAAW,OAAO,mBAAK,GAAE;AAAA,EAClC;AACF;AAfE;AAqBK,SAAS,OAAU,GAA8C;AACtE,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,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO,MAAM,UAAU,OAAO,cAAA,CAAe;AAC7C,WAAO;AAAA,EACT;AACF;;;"}