@tanstack/db-ivm 0.0.0 → 0.1.1

package/dist/esm/operators/filterBy.js

@@ -0,0 +1,19 @@
+import { map } from "./map.js";
+import { innerJoin } from "./join.js";
+import { consolidate } from "./consolidate.js";
+function filterBy(other) {
+  return (stream) => {
+    const otherKeys = other.pipe(
+      map(([key, _]) => [key, null])
+    );
+    return stream.pipe(
+      innerJoin(otherKeys),
+      map(([key, [value, _]]) => [key, value]),
+      consolidate()
+    );
+  };
+}
+export {
+  filterBy
+};
+//# sourceMappingURL=filterBy.js.map

package/dist/esm/operators/filterBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterBy.js","sources":["../../../src/operators/filterBy.ts"],"sourcesContent":["import { map } from \"./map.js\"\nimport { innerJoin } from \"./join.js\"\nimport { consolidate } from \"./consolidate.js\"\nimport type { KeyValue } from \"../types.js\"\nimport type { IStreamBuilder, PipedOperator } from \"../types\"\n\n/**\n * Filters the elements of a keyed stream, by keys of another stream.\n * This allows you to build pipelies where you have multiple outputs that are related,\n * such as a streams of issues and comments for a project.\n *\n * @param other - The other stream to filter by, which must have the same key type as the input stream\n */\nexport function filterBy<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, unknown>>\n): PipedOperator<T, KeyValue<K, V1>> {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<KeyValue<K, V1>> => {\n    const otherKeys = other.pipe(\n      map(([key, _]) => [key, null] as KeyValue<K, null>)\n    )\n    return stream.pipe(\n      innerJoin(otherKeys),\n      map(([key, [value, _]]) => [key, value] as KeyValue<K, V1>),\n      consolidate()\n    )\n  }\n}\n"],"names":[],"mappings":";;;AAaO,SAAS,SAKd,OACmC;AACnC,SAAO,CAAC,WAA+D;AACrE,UAAM,YAAY,MAAM;AAAA,MACtB,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,IAAI,CAAsB;AAAA,IAAA;AAEpD,WAAO,OAAO;AAAA,MACZ,UAAU,SAAS;AAAA,MACnB,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,KAAK,CAAoB;AAAA,MAC1D,YAAA;AAAA,IAAY;AAAA,EAEhB;AACF;"}

package/dist/esm/operators/groupBy.d.ts

@@ -0,0 +1,68 @@
+import { IStreamBuilder, KeyValue } from '../types.js';
+type GroupKey = Record<string, unknown>;
+type BasicAggregateFunction<T, R, V = unknown> = {
+    preMap: (data: T) => V;
+    reduce: (values: Array<[V, number]>) => V;
+    postMap?: (result: V) => R;
+};
+type PipedAggregateFunction<T, R> = {
+    pipe: (stream: IStreamBuilder<T>) => IStreamBuilder<KeyValue<string, R>>;
+};
+type AggregateFunction<T, R, V = unknown> = BasicAggregateFunction<T, R, V> | PipedAggregateFunction<T, R>;
+type ExtractAggregateReturnType<T, A> = A extends AggregateFunction<T, infer R, any> ? R : never;
+type AggregatesReturnType<T, A> = {
+    [K in keyof A]: ExtractAggregateReturnType<T, A[K]>;
+};
+/**
+ * Groups data by key and applies multiple aggregate operations
+ * @param keyExtractor Function to extract grouping key from data
+ * @param aggregates Object mapping aggregate names to aggregate functions
+ */
+export declare function groupBy<T, K extends GroupKey, A extends Record<string, AggregateFunction<T, any, any>>>(keyExtractor: (data: T) => K, aggregates?: A): (stream: IStreamBuilder<T>) => IStreamBuilder<KeyValue<string, K & AggregatesReturnType<T, A>>>;
+/**
+ * Creates a sum aggregate function
+ */
+export declare function sum<T>(valueExtractor?: (value: T) => number): AggregateFunction<T, number, number>;
+/**
+ * Creates a count aggregate function
+ */
+export declare function count<T>(): AggregateFunction<T, number, number>;
+/**
+ * Creates an average aggregate function
+ */
+export declare function avg<T>(valueExtractor?: (value: T) => number): AggregateFunction<T, number, {
+    sum: number;
+    count: number;
+}>;
+/**
+ * Creates a min aggregate function that computes the minimum value in a group
+ * @param valueExtractor Function to extract a numeric value from each data entry
+ */
+export declare function min<T>(valueExtractor?: (value: T) => number): AggregateFunction<T, number, number>;
+/**
+ * Creates a max aggregate function that computes the maximum value in a group
+ * @param valueExtractor Function to extract a numeric value from each data entry
+ */
+export declare function max<T>(valueExtractor?: (value: T) => number): AggregateFunction<T, number, number>;
+/**
+ * Creates a median aggregate function that computes the middle value in a sorted group
+ * If there's an even number of values, returns the average of the two middle values
+ * @param valueExtractor Function to extract a numeric value from each data entry
+ */
+export declare function median<T>(valueExtractor?: (value: T) => number): AggregateFunction<T, number, Array<number>>;
+/**
+ * Creates a mode aggregate function that computes the most frequent value in a group
+ * If multiple values have the same highest frequency, returns the first one encountered
+ * @param valueExtractor Function to extract a value from each data entry
+ */
+export declare function mode<T>(valueExtractor?: (value: T) => number): AggregateFunction<T, number, Map<number, number>>;
+export declare const groupByOperators: {
+    sum: typeof sum;
+    count: typeof count;
+    avg: typeof avg;
+    min: typeof min;
+    max: typeof max;
+    median: typeof median;
+    mode: typeof mode;
+};
+export {};

package/dist/esm/operators/groupBy.js

@@ -0,0 +1,225 @@
+import { map } from "./map.js";
+import { reduce } from "./reduce.js";
+function isPipedAggregateFunction(aggregate) {
+  return `pipe` in aggregate;
+}
+function groupBy(keyExtractor, aggregates = {}) {
+  const basicAggregates = Object.fromEntries(
+    Object.entries(aggregates).filter(
+      ([_, aggregate]) => !isPipedAggregateFunction(aggregate)
+    )
+  );
+  Object.fromEntries(
+    Object.entries(aggregates).filter(
+      ([_, aggregate]) => isPipedAggregateFunction(aggregate)
+    )
+  );
+  return (stream) => {
+    const KEY_SENTINEL = `__original_key__`;
+    const withKeysAndValues = stream.pipe(
+      map((data) => {
+        const key = keyExtractor(data);
+        const keyString = JSON.stringify(key);
+        const values = {};
+        values[KEY_SENTINEL] = key;
+        for (const [name, aggregate] of Object.entries(basicAggregates)) {
+          values[name] = aggregate.preMap(data);
+        }
+        return [keyString, values];
+      })
+    );
+    const reduced = withKeysAndValues.pipe(
+      reduce((values) => {
+        var _a, _b;
+        let totalMultiplicity = 0;
+        for (const [_, multiplicity] of values) {
+          totalMultiplicity += multiplicity;
+        }
+        if (totalMultiplicity <= 0) {
+          return [];
+        }
+        const result = {};
+        const originalKey = (_b = (_a = values[0]) == null ? void 0 : _a[0]) == null ? void 0 : _b[KEY_SENTINEL];
+        result[KEY_SENTINEL] = originalKey;
+        for (const [name, aggregate] of Object.entries(basicAggregates)) {
+          const preValues = values.map(
+            ([v, m]) => [v[name], m]
+          );
+          result[name] = aggregate.reduce(preValues);
+        }
+        return [[result, 1]];
+      })
+    );
+    return reduced.pipe(
+      map(([keyString, values]) => {
+        const key = values[KEY_SENTINEL];
+        const result = {};
+        Object.assign(result, key);
+        for (const [name, aggregate] of Object.entries(basicAggregates)) {
+          if (aggregate.postMap) {
+            result[name] = aggregate.postMap(values[name]);
+          } else {
+            result[name] = values[name];
+          }
+        }
+        return [keyString, result];
+      })
+    );
+  };
+}
+function sum(valueExtractor = (v) => v) {
+  return {
+    preMap: (data) => valueExtractor(data),
+    reduce: (values) => {
+      let total = 0;
+      for (const [value, multiplicity] of values) {
+        total += value * multiplicity;
+      }
+      return total;
+    }
+  };
+}
+function count() {
+  return {
+    preMap: () => 1,
+    reduce: (values) => {
+      let totalCount = 0;
+      for (const [_, multiplicity] of values) {
+        totalCount += multiplicity;
+      }
+      return totalCount;
+    }
+  };
+}
+function avg(valueExtractor = (v) => v) {
+  return {
+    preMap: (data) => ({
+      sum: valueExtractor(data),
+      count: 0
+    }),
+    reduce: (values) => {
+      let totalSum = 0;
+      let totalCount = 0;
+      for (const [value, multiplicity] of values) {
+        totalSum += value.sum * multiplicity;
+        totalCount += multiplicity;
+      }
+      return {
+        sum: totalSum,
+        count: totalCount
+      };
+    },
+    postMap: (result) => {
+      return result.sum / result.count;
+    }
+  };
+}
+function min(valueExtractor = (v) => v) {
+  return {
+    preMap: (data) => valueExtractor(data),
+    reduce: (values) => {
+      let minValue = Number.POSITIVE_INFINITY;
+      for (const [value, _multiplicity] of values) {
+        if (value < minValue) {
+          minValue = value;
+        }
+      }
+      return minValue === Number.POSITIVE_INFINITY ? 0 : minValue;
+    }
+  };
+}
+function max(valueExtractor = (v) => v) {
+  return {
+    preMap: (data) => valueExtractor(data),
+    reduce: (values) => {
+      let maxValue = Number.NEGATIVE_INFINITY;
+      for (const [value, _multiplicity] of values) {
+        if (value > maxValue) {
+          maxValue = value;
+        }
+      }
+      return maxValue === Number.NEGATIVE_INFINITY ? 0 : maxValue;
+    }
+  };
+}
+function median(valueExtractor = (v) => v) {
+  return {
+    preMap: (data) => [valueExtractor(data)],
+    reduce: (values) => {
+      const allValues = [];
+      for (const [valueArray, multiplicity] of values) {
+        for (const value of valueArray) {
+          for (let i = 0; i < multiplicity; i++) {
+            allValues.push(value);
+          }
+        }
+      }
+      if (allValues.length === 0) {
+        return [];
+      }
+      allValues.sort((a, b) => a - b);
+      return allValues;
+    },
+    postMap: (result) => {
+      if (result.length === 0) return 0;
+      const mid = Math.floor(result.length / 2);
+      if (result.length % 2 === 0) {
+        return (result[mid - 1] + result[mid]) / 2;
+      }
+      return result[mid];
+    }
+  };
+}
+function mode(valueExtractor = (v) => v) {
+  return {
+    preMap: (data) => {
+      const value = valueExtractor(data);
+      const frequencyMap = /* @__PURE__ */ new Map();
+      frequencyMap.set(value, 1);
+      return frequencyMap;
+    },
+    reduce: (values) => {
+      const combinedMap = /* @__PURE__ */ new Map();
+      for (const [frequencyMap, multiplicity] of values) {
+        for (const [value, frequencyCount] of frequencyMap.entries()) {
+          const currentCount = combinedMap.get(value) || 0;
+          combinedMap.set(value, currentCount + frequencyCount * multiplicity);
+        }
+      }
+      return combinedMap;
+    },
+    postMap: (result) => {
+      if (result.size === 0) return 0;
+      let modeValue = 0;
+      let maxFrequency = 0;
+      for (const [value, frequency] of result.entries()) {
+        if (frequency > maxFrequency) {
+          maxFrequency = frequency;
+          modeValue = value;
+        }
+      }
+      return modeValue;
+    }
+  };
+}
+const groupByOperators = {
+  sum,
+  count,
+  avg,
+  min,
+  max,
+  median,
+  mode
+};
+export {
+  avg,
+  count,
+  groupBy,
+  groupByOperators,
+  max,
+  median,
+  min,
+  mode,
+  sum
+};
+//# sourceMappingURL=groupBy.js.map

package/dist/esm/operators/groupBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"groupBy.js","sources":["../../../src/operators/groupBy.ts"],"sourcesContent":["import { map } from \"./map.js\"\nimport { reduce } from \"./reduce.js\"\nimport type { IStreamBuilder, KeyValue } from \"../types.js\"\n\ntype GroupKey = Record<string, unknown>\n\ntype BasicAggregateFunction<T, R, V = unknown> = {\n  preMap: (data: T) => V\n  reduce: (values: Array<[V, number]>) => V\n  postMap?: (result: V) => R\n}\n\ntype PipedAggregateFunction<T, R> = {\n  pipe: (stream: IStreamBuilder<T>) => IStreamBuilder<KeyValue<string, R>>\n}\n\ntype AggregateFunction<T, R, V = unknown> =\n  | BasicAggregateFunction<T, R, V>\n  | PipedAggregateFunction<T, R>\n\ntype ExtractAggregateReturnType<T, A> =\n  A extends AggregateFunction<T, infer R, any> ? R : never\n\ntype AggregatesReturnType<T, A> = {\n  [K in keyof A]: ExtractAggregateReturnType<T, A[K]>\n}\n\nfunction isPipedAggregateFunction<T, R>(\n  aggregate: AggregateFunction<T, R>\n): aggregate is PipedAggregateFunction<T, R> {\n  return `pipe` in aggregate\n}\n\n/**\n * Groups data by key and applies multiple aggregate operations\n * @param keyExtractor Function to extract grouping key from data\n * @param aggregates Object mapping aggregate names to aggregate functions\n */\nexport function groupBy<\n  T,\n  K extends GroupKey,\n  A extends Record<string, AggregateFunction<T, any, any>>,\n>(keyExtractor: (data: T) => K, aggregates: A = {} as A) {\n  type ResultType = K & AggregatesReturnType<T, A>\n\n  const basicAggregates = Object.fromEntries(\n    Object.entries(aggregates).filter(\n      ([_, aggregate]) => !isPipedAggregateFunction(aggregate)\n    )\n  ) as Record<string, BasicAggregateFunction<T, any, any>>\n\n  // @ts-expect-error - TODO: we don't use this yet, but we will\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  const pipedAggregates = Object.fromEntries(\n    Object.entries(aggregates).filter(([_, aggregate]) =>\n      isPipedAggregateFunction(aggregate)\n    )\n  ) as Record<string, PipedAggregateFunction<T, any>>\n\n  return (\n    stream: IStreamBuilder<T>\n  ): IStreamBuilder<KeyValue<string, ResultType>> => {\n    // Special key to store the original key object\n    const KEY_SENTINEL = `__original_key__`\n\n    // First map to extract keys and pre-aggregate values\n    const withKeysAndValues = stream.pipe(\n      map((data) => {\n        const key = keyExtractor(data)\n        const keyString = JSON.stringify(key)\n\n        // Create values object with pre-aggregated values\n        const values: Record<string, unknown> = {}\n\n        // Store the original key object\n        values[KEY_SENTINEL] = key\n\n        // Add pre-aggregated values\n        for (const [name, aggregate] of Object.entries(basicAggregates)) {\n          values[name] = aggregate.preMap(data)\n        }\n\n        return [keyString, values] as KeyValue<string, Record<string, unknown>>\n      })\n    )\n\n    // Then reduce to compute aggregates\n    const reduced = withKeysAndValues.pipe(\n      reduce((values) => {\n        // Calculate total multiplicity to check if the group should exist\n        let totalMultiplicity = 0\n        for (const [_, multiplicity] of values) {\n          totalMultiplicity += multiplicity\n        }\n\n        // If total multiplicity is 0 or negative, the group should be removed completely\n        if (totalMultiplicity <= 0) {\n          return []\n        }\n\n        const result: Record<string, unknown> = {}\n\n        // Get the original key from first value in group\n        const originalKey = values[0]?.[0]?.[KEY_SENTINEL]\n        result[KEY_SENTINEL] = originalKey\n\n        // Apply each aggregate function\n        for (const [name, aggregate] of Object.entries(basicAggregates)) {\n          const preValues = values.map(\n            ([v, m]) => [v[name], m] as [any, number]\n          )\n          result[name] = aggregate.reduce(preValues)\n        }\n\n        return [[result, 1]]\n      })\n    )\n\n    // Finally map to extract the key and include all values\n    return reduced.pipe(\n      map(([keyString, values]) => {\n        // Extract the original key\n        const key = values[KEY_SENTINEL] as K\n\n        // Create intermediate result with key values and aggregate results\n        const result: Record<string, unknown> = {}\n\n        // Add key properties to result\n        Object.assign(result, key)\n\n        // Apply postMap if provided\n        for (const [name, aggregate] of Object.entries(basicAggregates)) {\n          if (aggregate.postMap) {\n            result[name] = aggregate.postMap(values[name])\n          } else {\n            result[name] = values[name]\n          }\n        }\n\n        // Return with the string key instead of the object\n        return [keyString, result] as KeyValue<string, ResultType>\n      })\n    )\n  }\n}\n\n/**\n * Creates a sum aggregate function\n */\nexport function sum<T>(\n  valueExtractor: (value: T) => number = (v) => v as unknown as number\n): AggregateFunction<T, number, number> {\n  return {\n    preMap: (data: T) => valueExtractor(data),\n    reduce: (values: Array<[number, number]>) => {\n      let total = 0\n      for (const [value, multiplicity] of values) {\n        total += value * multiplicity\n      }\n      return total\n    },\n  }\n}\n\n/**\n * Creates a count aggregate function\n */\nexport function count<T>(): AggregateFunction<T, number, number> {\n  return {\n    preMap: () => 1,\n    reduce: (values: Array<[number, number]>) => {\n      let totalCount = 0\n      for (const [_, multiplicity] of values) {\n        totalCount += multiplicity\n      }\n      return totalCount\n    },\n  }\n}\n\n/**\n * Creates an average aggregate function\n */\nexport function avg<T>(\n  valueExtractor: (value: T) => number = (v) => v as unknown as number\n): AggregateFunction<T, number, { sum: number; count: number }> {\n  return {\n    preMap: (data: T) => ({\n      sum: valueExtractor(data),\n      count: 0,\n    }),\n    reduce: (values: Array<[{ sum: number; count: number }, number]>) => {\n      let totalSum = 0\n      let totalCount = 0\n      for (const [value, multiplicity] of values) {\n        totalSum += value.sum * multiplicity\n        totalCount += multiplicity\n      }\n      return {\n        sum: totalSum,\n        count: totalCount,\n      }\n    },\n    postMap: (result: { sum: number; count: number }) => {\n      return result.sum / result.count\n    },\n  }\n}\n\n/**\n * Creates a min aggregate function that computes the minimum value in a group\n * @param valueExtractor Function to extract a numeric value from each data entry\n */\nexport function min<T>(\n  valueExtractor: (value: T) => number = (v) => v as unknown as number\n): AggregateFunction<T, number, number> {\n  return {\n    preMap: (data: T) => valueExtractor(data),\n    reduce: (values: Array<[number, number]>) => {\n      let minValue = Number.POSITIVE_INFINITY\n      for (const [value, _multiplicity] of values) {\n        if (value < minValue) {\n          minValue = value\n        }\n      }\n      return minValue === Number.POSITIVE_INFINITY ? 0 : minValue\n    },\n  }\n}\n\n/**\n * Creates a max aggregate function that computes the maximum value in a group\n * @param valueExtractor Function to extract a numeric value from each data entry\n */\nexport function max<T>(\n  valueExtractor: (value: T) => number = (v) => v as unknown as number\n): AggregateFunction<T, number, number> {\n  return {\n    preMap: (data: T) => valueExtractor(data),\n    reduce: (values: Array<[number, number]>) => {\n      let maxValue = Number.NEGATIVE_INFINITY\n      for (const [value, _multiplicity] of values) {\n        if (value > maxValue) {\n          maxValue = value\n        }\n      }\n      return maxValue === Number.NEGATIVE_INFINITY ? 0 : maxValue\n    },\n  }\n}\n\n/**\n * Creates a median aggregate function that computes the middle value in a sorted group\n * If there's an even number of values, returns the average of the two middle values\n * @param valueExtractor Function to extract a numeric value from each data entry\n */\nexport function median<T>(\n  valueExtractor: (value: T) => number = (v) => v as unknown as number\n): AggregateFunction<T, number, Array<number>> {\n  return {\n    preMap: (data: T) => [valueExtractor(data)],\n    reduce: (values: Array<[Array<number>, number]>) => {\n      // Flatten all values, taking multiplicity into account\n      const allValues: Array<number> = []\n      for (const [valueArray, multiplicity] of values) {\n        for (const value of valueArray) {\n          // Add each value multiple times based on multiplicity\n          for (let i = 0; i < multiplicity; i++) {\n            allValues.push(value)\n          }\n        }\n      }\n\n      // Return empty array if no values\n      if (allValues.length === 0) {\n        return []\n      }\n\n      // Sort values\n      allValues.sort((a, b) => a - b)\n\n      return allValues\n    },\n    postMap: (result: Array<number>) => {\n      if (result.length === 0) return 0\n\n      const mid = Math.floor(result.length / 2)\n\n      // If even number of values, average the two middle values\n      if (result.length % 2 === 0) {\n        return (result[mid - 1]! + result[mid]!) / 2\n      }\n\n      // If odd number of values, return the middle value\n      return result[mid]!\n    },\n  }\n}\n\n/**\n * Creates a mode aggregate function that computes the most frequent value in a group\n * If multiple values have the same highest frequency, returns the first one encountered\n * @param valueExtractor Function to extract a value from each data entry\n */\nexport function mode<T>(\n  valueExtractor: (value: T) => number = (v) => v as unknown as number\n): AggregateFunction<T, number, Map<number, number>> {\n  return {\n    preMap: (data: T) => {\n      const value = valueExtractor(data)\n      const frequencyMap = new Map<number, number>()\n      frequencyMap.set(value, 1)\n      return frequencyMap\n    },\n    reduce: (values: Array<[Map<number, number>, number]>) => {\n      // Combine all frequency maps\n      const combinedMap = new Map<number, number>()\n\n      for (const [frequencyMap, multiplicity] of values) {\n        for (const [value, frequencyCount] of frequencyMap.entries()) {\n          const currentCount = combinedMap.get(value) || 0\n          combinedMap.set(value, currentCount + frequencyCount * multiplicity)\n        }\n      }\n\n      return combinedMap\n    },\n    postMap: (result: Map<number, number>) => {\n      if (result.size === 0) return 0\n\n      let modeValue = 0\n      let maxFrequency = 0\n\n      for (const [value, frequency] of result.entries()) {\n        if (frequency > maxFrequency) {\n          maxFrequency = frequency\n          modeValue = value\n        }\n      }\n\n      return modeValue\n    },\n  }\n}\n\nexport const groupByOperators = {\n  sum,\n  count,\n  avg,\n  min,\n  max,\n  median,\n  mode,\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/operators/index.d.ts

@@ -0,0 +1,18 @@
+export * from './pipe.js';
+export * from './map.js';
+export * from './filter.js';
+export * from './negate.js';
+export * from './concat.js';
+export * from './debug.js';
+export * from './output.js';
+export * from './consolidate.js';
+export * from './join.js';
+export * from './reduce.js';
+export * from './count.js';
+export * from './distinct.js';
+export * from './keying.js';
+export * from './topK.js';
+export * from './topKWithFractionalIndex.js';
+export * from './orderBy.js';
+export * from './filterBy.js';
+export { groupBy, groupByOperators } from './groupBy.js';

package/dist/esm/operators/join.d.ts

@@ -0,0 +1,48 @@
+import { BinaryOperator, DifferenceStreamWriter, DifferenceStreamReader } from '../graph.js';
+import { IStreamBuilder, KeyValue, PipedOperator } from '../types.js';
+/**
+ * Type of join to perform
+ */
+export type JoinType = `inner` | `left` | `right` | `full` | `anti`;
+/**
+ * Operator that joins two input streams
+ */
+export declare class JoinOperator<K, V1, V2> extends BinaryOperator<[
+    K,
+    V1
+] | [K, V2] | [K, [V1, V2]]> {
+    #private;
+    constructor(id: number, inputA: DifferenceStreamReader<[K, V1]>, inputB: DifferenceStreamReader<[K, V2]>, output: DifferenceStreamWriter<[K, [V1, V2]]>);
+    run(): void;
+}
+/**
+ * Joins two input streams
+ * @param other - The other stream to join with
+ * @param type - The type of join to perform
+ */
+export declare function join<K, V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never, V2, T>(other: IStreamBuilder<KeyValue<K, V2>>, type?: JoinType): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>>;
+/**
+ * Joins two input streams
+ * @param other - The other stream to join with
+ */
+export declare 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]>>;
+/**
+ * Joins two input streams
+ * @param other - The other stream to join with
+ */
+export declare 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]>>;
+/**
+ * Joins two input streams
+ * @param other - The other stream to join with
+ */
+export declare 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]>>;
+/**
+ * Joins two input streams
+ * @param other - The other stream to join with
+ */
+export declare 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]>>;
+/**
+ * Joins two input streams
+ * @param other - The other stream to join with
+ */
+export declare 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]>>;

package/dist/esm/operators/join.js

@@ -0,0 +1,145 @@
+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 _indexA, _indexB;
+import { BinaryOperator, DifferenceStreamWriter } from "../graph.js";
+import { StreamBuilder } from "../d2.js";
+import { MultiSet } from "../multiset.js";
+import { Index } from "../indexes.js";
+import { negate } from "./negate.js";
+import { map } from "./map.js";
+import { concat } from "./concat.js";
+class JoinOperator extends BinaryOperator {
+  constructor(id, inputA, inputB, output) {
+    super(id, inputA, inputB, output);
+    __privateAdd(this, _indexA, new Index());
+    __privateAdd(this, _indexB, new Index());
+  }
+  run() {
+    const deltaA = new Index();
+    const deltaB = new Index();
+    const messagesA = this.inputAMessages();
+    for (const message of messagesA) {
+      const multiSetMessage = message;
+      for (const [item, multiplicity] of multiSetMessage.getInner()) {
+        const [key, value] = item;
+        deltaA.addValue(key, [value, multiplicity]);
+      }
+    }
+    const messagesB = this.inputBMessages();
+    for (const message of messagesB) {
+      const multiSetMessage = message;
+      for (const [item, multiplicity] of multiSetMessage.getInner()) {
+        const [key, value] = item;
+        deltaB.addValue(key, [value, multiplicity]);
+      }
+    }
+    const results = new MultiSet();
+    results.extend(deltaA.join(__privateGet(this, _indexB)));
+    __privateGet(this, _indexA).append(deltaA);
+    results.extend(__privateGet(this, _indexA).join(deltaB));
+    if (results.getInner().length > 0) {
+      this.output.sendData(results);
+    }
+    __privateGet(this, _indexB).append(deltaB);
+  }
+}
+_indexA = new WeakMap();
+_indexB = new WeakMap();
+function join(other, type = `inner`) {
+  switch (type) {
+    case `inner`:
+      return innerJoin(other);
+    case `anti`:
+      return antiJoin(other);
+    case `left`:
+      return leftJoin(other);
+    case `right`:
+      return rightJoin(other);
+    case `full`:
+      return fullJoin(other);
+    default:
+      throw new Error(`Join type ${type} is invalid`);
+  }
+}
+function innerJoin(other) {
+  return (stream) => {
+    if (stream.graph !== other.graph) {
+      throw new Error(`Cannot join streams from different graphs`);
+    }
+    const output = new StreamBuilder(
+      stream.graph,
+      new DifferenceStreamWriter()
+    );
+    const operator = new JoinOperator(
+      stream.graph.getNextOperatorId(),
+      stream.connectReader(),
+      other.connectReader(),
+      output.writer
+    );
+    stream.graph.addOperator(operator);
+    stream.graph.addStream(output.connectReader());
+    return output;
+  };
+}
+function antiJoin(other) {
+  return (stream) => {
+    const matchedLeft = stream.pipe(
+      innerJoin(other),
+      map(([key, [valueLeft, _valueRight]]) => [key, valueLeft])
+    );
+    const anti = stream.pipe(
+      concat(matchedLeft.pipe(negate())),
+      // @ts-ignore TODO: fix this
+      map(([key, value]) => [key, [value, null]])
+    );
+    return anti;
+  };
+}
+function leftJoin(other) {
+  return (stream) => {
+    const left = stream;
+    const right = other;
+    const inner = left.pipe(innerJoin(right));
+    const anti = left.pipe(antiJoin(right));
+    return inner.pipe(concat(anti));
+  };
+}
+function rightJoin(other) {
+  return (stream) => {
+    const left = stream;
+    const right = other;
+    const inner = left.pipe(innerJoin(right));
+    const anti = right.pipe(
+      antiJoin(left),
+      map(([key, [a, b]]) => [key, [b, a]])
+    );
+    return inner.pipe(concat(anti));
+  };
+}
+function fullJoin(other) {
+  return (stream) => {
+    const left = stream;
+    const right = other;
+    const inner = left.pipe(innerJoin(right));
+    const antiLeft = left.pipe(antiJoin(right));
+    const antiRight = right.pipe(
+      antiJoin(left),
+      map(([key, [a, b]]) => [key, [b, a]])
+    );
+    return inner.pipe(concat(antiLeft), concat(antiRight));
+  };
+}
+export {
+  JoinOperator,
+  antiJoin,
+  fullJoin,
+  innerJoin,
+  join,
+  leftJoin,
+  rightJoin
+};
+//# sourceMappingURL=join.js.map

package/dist/esm/operators/join.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.js","sources":["../../../src/operators/join.ts"],"sourcesContent":["import { BinaryOperator, DifferenceStreamWriter } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport { MultiSet } from \"../multiset.js\"\nimport { Index } from \"../indexes.js\"\nimport { negate } from \"./negate.js\"\nimport { map } from \"./map.js\"\nimport { concat } from \"./concat.js\"\nimport type { DifferenceStreamReader } from \"../graph.js\"\nimport type { IStreamBuilder, KeyValue, PipedOperator } from \"../types.js\"\n\n/**\n * Type of join to perform\n */\nexport type JoinType = `inner` | `left` | `right` | `full` | `anti`\n\n/**\n * Operator that joins two input streams\n */\nexport class JoinOperator<K, V1, V2> extends BinaryOperator<\n  [K, V1] | [K, V2] | [K, [V1, V2]]\n> {\n  #indexA = new Index<K, V1>()\n  #indexB = new Index<K, V2>()\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<[K, V1]>,\n    inputB: DifferenceStreamReader<[K, V2]>,\n    output: DifferenceStreamWriter<[K, [V1, V2]]>\n  ) {\n    super(id, inputA, inputB, output)\n  }\n\n  run(): void {\n    const deltaA = new Index<K, V1>()\n    const deltaB = new Index<K, V2>()\n\n    // Process input A - process ALL messages, not just the first one\n    const messagesA = this.inputAMessages()\n    for (const message of messagesA) {\n      const multiSetMessage = message as unknown as MultiSet<[K, V1]>\n      for (const [item, multiplicity] of multiSetMessage.getInner()) {\n        const [key, value] = item\n        deltaA.addValue(key, [value, multiplicity])\n      }\n    }\n\n    // Process input B - process ALL messages, not just the first one\n    const messagesB = this.inputBMessages()\n    for (const message of messagesB) {\n      const multiSetMessage = message as unknown as MultiSet<[K, V2]>\n      for (const [item, multiplicity] of multiSetMessage.getInner()) {\n        const [key, value] = item\n        deltaB.addValue(key, [value, multiplicity])\n      }\n    }\n\n    // Process results\n    const results = new MultiSet<[K, [V1, V2]]>()\n\n    // Join deltaA with existing indexB\n    results.extend(deltaA.join(this.#indexB))\n\n    // Append deltaA to indexA\n    this.#indexA.append(deltaA)\n\n    // Join existing indexA with deltaB\n    results.extend(this.#indexA.join(deltaB))\n\n    // Send results\n    if (results.getInner().length > 0) {\n      this.output.sendData(results)\n    }\n\n    // Append deltaB to indexB\n    this.#indexB.append(deltaB)\n  }\n}\n\n/**\n * Joins two input streams\n * @param other - The other stream to join with\n * @param type - The type of join to perform\n */\nexport function join<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>,\n  type: JoinType = `inner`\n): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {\n  switch (type) {\n    case `inner`:\n      return innerJoin(other) as unknown as PipedOperator<\n        T,\n        KeyValue<K, [V1, V2]>\n      >\n    case `anti`:\n      return antiJoin(other) as unknown as PipedOperator<\n        T,\n        KeyValue<K, [V1, null]>\n      >\n    case `left`:\n      return leftJoin(other) as unknown as PipedOperator<\n        T,\n        KeyValue<K, [V1, V2 | null]>\n      >\n    case `right`:\n      return rightJoin(other) as unknown as PipedOperator<\n        T,\n        KeyValue<K, [V1 | null, V2]>\n      >\n    case `full`:\n      return fullJoin(other) as unknown as PipedOperator<\n        T,\n        KeyValue<K, [V1 | null, V2 | null]>\n      >\n    default:\n      throw new Error(`Join type ${type} is invalid`)\n  }\n}\n\n/**\n * Joins two input streams\n * @param other - The other stream to join with\n */\nexport function innerJoin<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>\n): PipedOperator<T, KeyValue<K, [V1, V2]>> {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<KeyValue<K, [V1, V2]>> => {\n    if (stream.graph !== other.graph) {\n      throw new Error(`Cannot join streams from different graphs`)\n    }\n    const output = new StreamBuilder<KeyValue<K, [V1, V2]>>(\n      stream.graph,\n      new DifferenceStreamWriter<KeyValue<K, [V1, V2]>>()\n    )\n    const operator = new JoinOperator<K, V1, V2>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader() as DifferenceStreamReader<KeyValue<K, V1>>,\n      other.connectReader(),\n      output.writer\n    )\n    stream.graph.addOperator(operator)\n    stream.graph.addStream(output.connectReader())\n    return output\n  }\n}\n\n/**\n * Joins two input streams\n * @param other - The other stream to join with\n */\nexport function antiJoin<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>\n): PipedOperator<T, KeyValue<K, [V1, null]>> {\n  return (\n    stream: IStreamBuilder<T>\n  ): IStreamBuilder<KeyValue<K, [V1, null]>> => {\n    const matchedLeft = stream.pipe(\n      innerJoin(other),\n      map(([key, [valueLeft, _valueRight]]) => [key, valueLeft])\n    )\n    const anti = stream.pipe(\n      concat(matchedLeft.pipe(negate())),\n      // @ts-ignore TODO: fix this\n      map(([key, value]) => [key, [value, null]])\n    )\n    return anti as IStreamBuilder<KeyValue<K, [V1, null]>>\n  }\n}\n\n/**\n * Joins two input streams\n * @param other - The other stream to join with\n */\nexport function leftJoin<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>\n): PipedOperator<T, KeyValue<K, [V1, V2 | null]>> {\n  return (\n    stream: IStreamBuilder<T>\n  ): IStreamBuilder<KeyValue<K, [V1, V2 | null]>> => {\n    const left = stream\n    const right = other\n    const inner = left.pipe(innerJoin(right))\n    const anti = left.pipe(antiJoin(right))\n    return inner.pipe(concat(anti)) as IStreamBuilder<\n      KeyValue<K, [V1, V2 | null]>\n    >\n  }\n}\n\n/**\n * Joins two input streams\n * @param other - The other stream to join with\n */\nexport function rightJoin<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>\n): PipedOperator<T, KeyValue<K, [V1 | null, V2]>> {\n  return (\n    stream: IStreamBuilder<T>\n  ): IStreamBuilder<KeyValue<K, [V1 | null, V2]>> => {\n    const left = stream as IStreamBuilder<KeyValue<K, V1>>\n    const right = other\n    const inner = left.pipe(innerJoin(right))\n    const anti = right.pipe(\n      antiJoin(left),\n      map(([key, [a, b]]) => [key, [b, a]])\n    )\n    return inner.pipe(concat(anti)) as IStreamBuilder<\n      KeyValue<K, [V1 | null, V2]>\n    >\n  }\n}\n\n/**\n * Joins two input streams\n * @param other - The other stream to join with\n */\nexport function fullJoin<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>\n): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {\n  return (\n    stream: IStreamBuilder<T>\n  ): IStreamBuilder<KeyValue<K, [V1 | null, V2 | null]>> => {\n    const left = stream as IStreamBuilder<KeyValue<K, V1>>\n    const right = other\n    const inner = left.pipe(innerJoin(right))\n    const antiLeft = left.pipe(antiJoin(right))\n    const antiRight = right.pipe(\n      antiJoin(left),\n      map(([key, [a, b]]) => [key, [b, a]])\n    )\n    return inner.pipe(concat(antiLeft), concat(antiRight)) as IStreamBuilder<\n      KeyValue<K, [V1 | null, V2 | null]>\n    >\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/operators/keying.d.ts

@@ -0,0 +1,19 @@
+import { PipedOperator } from '../types.js';
+/**
+ * Type for a keyed value
+ */
+export type Keyed<K, V> = [K, V];
+/**
+ * Takes an unkeyed input and returns a keyed result
+ * @param keyFn - Function to generate the key for each value
+ */
+export declare function keyBy<T, K>(keyFn: (value: T) => K): PipedOperator<T, Keyed<K, T>>;
+/**
+ * Removes the key from a keyed stream
+ */
+export declare function unkey<K, V>(): PipedOperator<Keyed<K, V>, V>;
+/**
+ * Takes a keyed input and rekeys it with a new key
+ * @param keyFn - Function to generate the new key for each value
+ */
+export declare function rekey<K1, K2, V>(keyFn: (value: V) => K2): PipedOperator<Keyed<K1, V>, Keyed<K2, V>>;

package/dist/esm/operators/keying.js

@@ -0,0 +1,16 @@
+import { map } from "./map.js";
+function keyBy(keyFn) {
+  return map((value) => [keyFn(value), value]);
+}
+function unkey() {
+  return map(([_, value]) => value);
+}
+function rekey(keyFn) {
+  return map(([_, value]) => [keyFn(value), value]);
+}
+export {
+  keyBy,
+  rekey,
+  unkey
+};
+//# sourceMappingURL=keying.js.map

package/dist/esm/operators/keying.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keying.js","sources":["../../../src/operators/keying.ts"],"sourcesContent":["import { map } from \"./map.js\"\nimport type { PipedOperator } from \"../types.js\"\n\n/**\n * Type for a keyed value\n */\nexport type Keyed<K, V> = [K, V]\n\n/**\n * Takes an unkeyed input and returns a keyed result\n * @param keyFn - Function to generate the key for each value\n */\nexport function keyBy<T, K>(\n  keyFn: (value: T) => K\n): PipedOperator<T, Keyed<K, T>> {\n  return map((value: T): Keyed<K, T> => [keyFn(value), value])\n}\n\n/**\n * Removes the key from a keyed stream\n */\nexport function unkey<K, V>(): PipedOperator<Keyed<K, V>, V> {\n  return map(([_, value]: Keyed<K, V>): V => value)\n}\n\n/**\n * Takes a keyed input and rekeys it with a new key\n * @param keyFn - Function to generate the new key for each value\n */\nexport function rekey<K1, K2, V>(\n  keyFn: (value: V) => K2\n): PipedOperator<Keyed<K1, V>, Keyed<K2, V>> {\n  return map(([_, value]: Keyed<K1, V>): Keyed<K2, V> => [keyFn(value), value])\n}\n"],"names":[],"mappings":";AAYO,SAAS,MACd,OAC+B;AAC/B,SAAO,IAAI,CAAC,UAA0B,CAAC,MAAM,KAAK,GAAG,KAAK,CAAC;AAC7D;AAKO,SAAS,QAA6C;AAC3D,SAAO,IAAI,CAAC,CAAC,GAAG,KAAK,MAAsB,KAAK;AAClD;AAMO,SAAS,MACd,OAC2C;AAC3C,SAAO,IAAI,CAAC,CAAC,GAAG,KAAK,MAAkC,CAAC,MAAM,KAAK,GAAG,KAAK,CAAC;AAC9E;"}

package/dist/esm/operators/map.d.ts

@@ -0,0 +1,16 @@
+import { DifferenceStreamWriter, LinearUnaryOperator, DifferenceStreamReader } from '../graph.js';
+import { PipedOperator } from '../types.js';
+import { MultiSet } from '../multiset.js';
+/**
+ * Operator that applies a function to each element in the input stream
+ */
+export declare class MapOperator<T, U> extends LinearUnaryOperator<T, U> {
+    #private;
+    constructor(id: number, inputA: DifferenceStreamReader<T>, output: DifferenceStreamWriter<U>, f: (data: T) => U);
+    inner(collection: MultiSet<T>): MultiSet<U>;
+}
+/**
+ * Applies a function to each element in the input stream
+ * @param f - The function to apply to each element
+ */
+export declare function map<T, O>(f: (data: T) => O): PipedOperator<T, O>;