@tanstack/db-ivm 0.1.25 → 0.1.26

package/dist/cjs/d2.d.cts

@@ -1,6 +1,6 @@
-import { DifferenceStreamWriter, BinaryOperator, DifferenceStreamReader, UnaryOperator } from './graph.js';
-import { MultiSet, MultiSetArray } from './multiset.js';
-import { ID2, IStreamBuilder, PipedOperator } from './types.js';
+import { DifferenceStreamWriter, BinaryOperator, DifferenceStreamReader, UnaryOperator } from "./graph.cjs";
+import { MultiSet, MultiSetArray } from "./multiset.cjs";
+import { ID2, IStreamBuilder, PipedOperator } from "./types.cjs";
 export declare class D2 implements ID2 {
     #private;
     constructor();

package/dist/cjs/graph.d.cts

@@ -1,5 +1,5 @@
-import { MultiSet, MultiSetArray } from './multiset.js';
-import { IDifferenceStreamReader, IDifferenceStreamWriter, IOperator } from './types.js';
+import { MultiSet, MultiSetArray } from "./multiset.cjs";
+import { IDifferenceStreamReader, IDifferenceStreamWriter, IOperator } from "./types.cjs";
 /**
  * A read handle to a dataflow edge that receives data from a writer.
  */

package/dist/cjs/hashing/index.d.cts

@@ -1,2 +1,2 @@
-export { hash } from './hash.js';
-export type { Hash, Hasher } from './murmur.js';
+export { hash } from "./hash.cjs";
+export type { Hash, Hasher } from "./murmur.cjs";

package/dist/cjs/index.cjs

@@ -4,27 +4,27 @@ const d2 = require("./d2.cjs");
 const multiset = require("./multiset.cjs");
 const utils = require("./utils.cjs");
 const hash = require("./hashing/hash.cjs");
-const groupBy = require("./operators/groupBy.cjs");
-const pipe = require("./operators/pipe.cjs");
-const map = require("./operators/map.cjs");
-const tap = require("./operators/tap.cjs");
-const filter = require("./operators/filter.cjs");
-const negate = require("./operators/negate.cjs");
 const concat = require("./operators/concat.cjs");
-const debug = require("./operators/debug.cjs");
-const output = require("./operators/output.cjs");
 const consolidate = require("./operators/consolidate.cjs");
-const join = require("./operators/join.cjs");
-const reduce = require("./operators/reduce.cjs");
 const count = require("./operators/count.cjs");
+const debug = require("./operators/debug.cjs");
 const distinct = require("./operators/distinct.cjs");
-const keying = require("./operators/keying.cjs");
-const topK = require("./operators/topK.cjs");
-const topKWithFractionalIndex = require("./operators/topKWithFractionalIndex.cjs");
+const filter = require("./operators/filter.cjs");
 const groupedTopKWithFractionalIndex = require("./operators/groupedTopKWithFractionalIndex.cjs");
-const orderBy = require("./operators/orderBy.cjs");
-const groupedOrderBy = require("./operators/groupedOrderBy.cjs");
+const join = require("./operators/join.cjs");
+const map = require("./operators/map.cjs");
+const negate = require("./operators/negate.cjs");
+const output = require("./operators/output.cjs");
+const reduce = require("./operators/reduce.cjs");
+const tap = require("./operators/tap.cjs");
+const topKWithFractionalIndex = require("./operators/topKWithFractionalIndex.cjs");
 const filterBy = require("./operators/filterBy.cjs");
+const groupBy = require("./operators/groupBy.cjs");
+const groupedOrderBy = require("./operators/groupedOrderBy.cjs");
+const keying = require("./operators/keying.cjs");
+const orderBy = require("./operators/orderBy.cjs");
+const pipe = require("./operators/pipe.cjs");
+const topK = require("./operators/topK.cjs");
 exports.D2 = d2.D2;
 exports.RootStreamBuilder = d2.RootStreamBuilder;
 exports.StreamBuilder = d2.StreamBuilder;
@@ -32,25 +32,20 @@ exports.MultiSet = multiset.MultiSet;
 exports.compareKeys = utils.compareKeys;
 exports.serializeValue = utils.serializeValue;
 exports.registerOpaqueHash = hash.registerOpaqueHash;
-exports.groupBy = groupBy.groupBy;
-exports.groupByOperators = groupBy.groupByOperators;
-exports.pipe = pipe.pipe;
-exports.MapOperator = map.MapOperator;
-exports.map = map.map;
-exports.TapOperator = tap.TapOperator;
-exports.tap = tap.tap;
-exports.FilterOperator = filter.FilterOperator;
-exports.filter = filter.filter;
-exports.NegateOperator = negate.NegateOperator;
-exports.negate = negate.negate;
 exports.ConcatOperator = concat.ConcatOperator;
 exports.concat = concat.concat;
-exports.DebugOperator = debug.DebugOperator;
-exports.debug = debug.debug;
-exports.OutputOperator = output.OutputOperator;
-exports.output = output.output;
 exports.ConsolidateOperator = consolidate.ConsolidateOperator;
 exports.consolidate = consolidate.consolidate;
+exports.CountOperator = count.CountOperator;
+exports.count = count.count;
+exports.DebugOperator = debug.DebugOperator;
+exports.debug = debug.debug;
+exports.DistinctOperator = distinct.DistinctOperator;
+exports.distinct = distinct.distinct;
+exports.FilterOperator = filter.FilterOperator;
+exports.filter = filter.filter;
+exports.GroupedTopKWithFractionalIndexOperator = groupedTopKWithFractionalIndex.GroupedTopKWithFractionalIndexOperator;
+exports.groupedTopKWithFractionalIndex = groupedTopKWithFractionalIndex.groupedTopKWithFractionalIndex;
 exports.JoinOperator = join.JoinOperator;
 exports.antiJoin = join.antiJoin;
 exports.fullJoin = join.fullJoin;
@@ -58,25 +53,30 @@ exports.innerJoin = join.innerJoin;
 exports.join = join.join;
 exports.leftJoin = join.leftJoin;
 exports.rightJoin = join.rightJoin;
+exports.MapOperator = map.MapOperator;
+exports.map = map.map;
+exports.NegateOperator = negate.NegateOperator;
+exports.negate = negate.negate;
+exports.OutputOperator = output.OutputOperator;
+exports.output = output.output;
 exports.ReduceOperator = reduce.ReduceOperator;
 exports.reduce = reduce.reduce;
-exports.CountOperator = count.CountOperator;
-exports.count = count.count;
-exports.DistinctOperator = distinct.DistinctOperator;
-exports.distinct = distinct.distinct;
+exports.TapOperator = tap.TapOperator;
+exports.tap = tap.tap;
+exports.TopKWithFractionalIndexOperator = topKWithFractionalIndex.TopKWithFractionalIndexOperator;
+exports.topKWithFractionalIndex = topKWithFractionalIndex.topKWithFractionalIndex;
+exports.filterBy = filterBy.filterBy;
+exports.groupBy = groupBy.groupBy;
+exports.groupByOperators = groupBy.groupByOperators;
+exports.groupedOrderByWithFractionalIndex = groupedOrderBy.groupedOrderByWithFractionalIndex;
 exports.keyBy = keying.keyBy;
 exports.rekey = keying.rekey;
 exports.unkey = keying.unkey;
-exports.topK = topK.topK;
-exports.topKWithIndex = topK.topKWithIndex;
-exports.TopKWithFractionalIndexOperator = topKWithFractionalIndex.TopKWithFractionalIndexOperator;
-exports.topKWithFractionalIndex = topKWithFractionalIndex.topKWithFractionalIndex;
-exports.GroupedTopKWithFractionalIndexOperator = groupedTopKWithFractionalIndex.GroupedTopKWithFractionalIndexOperator;
-exports.groupedTopKWithFractionalIndex = groupedTopKWithFractionalIndex.groupedTopKWithFractionalIndex;
 exports.orderBy = orderBy.orderBy;
 exports.orderByWithFractionalIndex = orderBy.orderByWithFractionalIndex;
 exports.orderByWithFractionalIndexBase = orderBy.orderByWithFractionalIndexBase;
 exports.orderByWithIndex = orderBy.orderByWithIndex;
-exports.groupedOrderByWithFractionalIndex = groupedOrderBy.groupedOrderByWithFractionalIndex;
-exports.filterBy = filterBy.filterBy;
+exports.pipe = pipe.pipe;
+exports.topK = topK.topK;
+exports.topKWithIndex = topK.topKWithIndex;
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/index.d.cts

@@ -1,6 +1,6 @@
-export * from './d2.js';
-export * from './multiset.js';
-export * from './operators/index.js';
-export * from './types.js';
-export { compareKeys, serializeValue } from './utils.js';
-export { registerOpaqueHash } from './hashing/hash.js';
+export * from "./d2.cjs";
+export * from "./multiset.cjs";
+export * from "./operators/index.cjs";
+export * from "./types.cjs";
+export { compareKeys, serializeValue } from "./utils.cjs";
+export { registerOpaqueHash } from "./hashing/hash.cjs";

package/dist/cjs/indexes.d.cts

@@ -1,5 +1,8 @@
-import { MultiSet } from './multiset.js';
-type SingleValue<TValue> = [TValue, number];
+import { MultiSet } from "./multiset.cjs";
+type SingleValue<TValue> = [
+    TValue,
+    number
+];
 /**
  * A map from a difference collection trace's keys -> (value, multiplicities) that changed.
  * Used in operations like join and reduce where the operation needs to
@@ -13,7 +16,10 @@ export declare class Index<TKey, TValue, TPrefix = any> {
      * @param messages - Array of MultiSet messages to build the index from.
      * @returns A new Index containing all the data from the messages.
      */
-    static fromMultiSets<K, V>(messages: Array<MultiSet<[K, V]>>): Index<K, V>;
+    static fromMultiSets<K, V>(messages: Array<MultiSet<[
+        K,
+        V
+    ]>>): Index<K, V>;
     /**
      * This method returns a string representation of the index.
      * @param indent - Whether to indent the string representation.
@@ -52,25 +58,43 @@ export declare class Index<TKey, TValue, TPrefix = any> {
      * @param key - The key to get the values for.
      * @returns An array of value tuples [value, multiplicity].
      */
-    get(key: TKey): Array<[TValue, number]>;
+    get(key: TKey): Array<[
+        TValue,
+        number
+    ]>;
     /**
      * This method returns an iterator over all values for a given key.
      * @param key - The key to get the values for.
      * @returns An iterator of value tuples [value, multiplicity].
      */
-    getIterator(key: TKey): Iterable<[TValue, number]>;
+    getIterator(key: TKey): Iterable<[
+        TValue,
+        number
+    ]>;
     /**
      * This returns an iterator that iterates over all key-value pairs.
      * @returns An iterable of all key-value pairs (and their multiplicities) in the index.
      */
-    entries(): Iterable<[TKey, [TValue, number]]>;
+    entries(): Iterable<[
+        TKey,
+        [
+            TValue,
+            number
+        ]
+    ]>;
     /**
      * This method only iterates over the keys and not over the values.
      * Hence, it is more efficient than the `#entries` method.
      * It returns an iterator that you can use if you need to iterate over the values for a given key.
      * @returns An iterator of all *keys* in the index and their corresponding value iterator.
      */
-    entriesIterators(): Iterable<[TKey, Iterable<[TValue, number]>]>;
+    entriesIterators(): Iterable<[
+        TKey,
+        Iterable<[
+            TValue,
+            number
+        ]>
+    ]>;
     /**
      * This method adds a value to the index.
      * @param key - The key to add the value to.
@@ -87,6 +111,12 @@ export declare class Index<TKey, TValue, TPrefix = any> {
      * @param other - The index to join with the current index.
      * @returns A multiset of the joined values.
      */
-    join<TValue2>(other: Index<TKey, TValue2>): MultiSet<[TKey, [TValue, TValue2]]>;
+    join<TValue2>(other: Index<TKey, TValue2>): MultiSet<[
+        TKey,
+        [
+            TValue,
+            TValue2
+        ]
+    ]>;
 }
 export {};

package/dist/cjs/multiset.d.cts

@@ -1,5 +1,11 @@
-export type MultiSetArray<T> = Array<[T, number]>;
-export type KeyedData<T> = [key: string, value: T];
+export type MultiSetArray<T> = Array<[
+    T,
+    number
+]>;
+export type KeyedData<T> = [
+    key: string,
+    value: T
+];
 /**
  * A multiset of data.
  */

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

@@ -1,5 +1,5 @@
-import { BinaryOperator } from '../graph.js';
-import { IStreamBuilder, PipedOperator } from '../types.js';
+import { BinaryOperator } from "../graph.cjs";
+import { IStreamBuilder, PipedOperator } from "../types.cjs";
 /**
  * Operator that concatenates two input streams
  */

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

@@ -1,5 +1,5 @@
-import { UnaryOperator } from '../graph.js';
-import { PipedOperator } from '../types.js';
+import { UnaryOperator } from "../graph.cjs";
+import { PipedOperator } from "../types.cjs";
 /**
  * Operator that consolidates collections
  */

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

@@ -1 +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    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;;;"}
+{"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,13 +1,19 @@
-import { DifferenceStreamWriter, DifferenceStreamReader } from '../graph.js';
-import { ReduceOperator } from './reduce.js';
-import { IStreamBuilder, KeyValue } from '../types.js';
+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]>);
+    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>>;
+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.d.cts

@@ -1,5 +1,5 @@
-import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from '../graph.js';
-import { PipedOperator } from '../types.js';
+import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from "../graph.cjs";
+import { PipedOperator } from "../types.cjs";
 /**
  * Operator that logs debug information about the stream
  */

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

@@ -1,5 +1,5 @@
-import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from '../graph.js';
-import { IStreamBuilder, KeyValue } from '../types.js';
+import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from "../graph.cjs";
+import { IStreamBuilder, KeyValue } from "../types.cjs";
 type GetValue<T> = T extends KeyValue<any, infer V> ? V : never;
 /**
  * Operator that removes duplicates

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

@@ -1,6 +1,6 @@
-import { DifferenceStreamWriter, LinearUnaryOperator, DifferenceStreamReader } from '../graph.js';
-import { PipedOperator } from '../types.js';
-import { MultiSet } from '../multiset.js';
+import { DifferenceStreamWriter, LinearUnaryOperator, DifferenceStreamReader } from "../graph.cjs";
+import { PipedOperator } from "../types.cjs";
+import { MultiSet } from "../multiset.cjs";
 /**
  * Operator that filters elements from the input stream
  */

package/dist/cjs/operators/filterBy.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"filterBy.cjs","sources":["../../../src/operators/filterBy.ts"],"sourcesContent":["import { map } from './map.js'\nimport { innerJoin } from './join.js'\nimport { consolidate } from './consolidate.js'\nimport type { IStreamBuilder, KeyValue, PipedOperator } from '../types.js'\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":["map","innerJoin","consolidate"],"mappings":";;;;;AAYO,SAAS,SAKd,OACmC;AACnC,SAAO,CAAC,WAA+D;AACrE,UAAM,YAAY,MAAM;AAAA,MACtBA,IAAAA,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,IAAI,CAAsB;AAAA,IAAA;AAEpD,WAAO,OAAO;AAAA,MACZC,KAAAA,UAAU,SAAS;AAAA,MACnBD,QAAI,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,KAAK,CAAoB;AAAA,MAC1DE,YAAAA,YAAA;AAAA,IAAY;AAAA,EAEhB;AACF;;"}
+{"version":3,"file":"filterBy.cjs","sources":["../../../src/operators/filterBy.ts"],"sourcesContent":["import { map } from './map.js'\nimport { innerJoin } from './join.js'\nimport { consolidate } from './consolidate.js'\nimport type { IStreamBuilder, KeyValue, PipedOperator } from '../types.js'\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":["map","innerJoin","consolidate"],"mappings":";;;;;AAYO,SAAS,SAKd,OACmC;AACnC,SAAO,CAAC,WAA+D;AACrE,UAAM,YAAY,MAAM;AAAA,MACtBA,IAAAA,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,IAAI,CAAsB;AAAA,IAAA;AAEpD,WAAO,OAAO;AAAA,MACZC,KAAAA,UAAU,SAAS;AAAA,MACnBD,QAAI,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,KAAK,CAAoB;AAAA,MAC1DE,YAAAA,YAAA;AAAA,IAAY;AAAA,EAEhB;AACF;;"}

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

@@ -1,4 +1,4 @@
-import { IStreamBuilder, KeyValue, PipedOperator } from '../types.js';
+import { IStreamBuilder, KeyValue, PipedOperator } from "../types.cjs";
 /**
  * Filters the elements of a keyed stream, by keys of another stream.
  * This allows you to build pipelies where you have multiple outputs that are related,
@@ -6,4 +6,4 @@ import { IStreamBuilder, KeyValue, PipedOperator } from '../types.js';
  *
  * @param other - The other stream to filter by, which must have the same key type as the input stream
  */
-export declare function filterBy<K, V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never, T>(other: IStreamBuilder<KeyValue<K, unknown>>): PipedOperator<T, KeyValue<K, V1>>;
+export declare function filterBy<K, V1 extends (T extends KeyValue<infer _KT, infer VT> ? VT : never), T>(other: IStreamBuilder<KeyValue<K, unknown>>): PipedOperator<T, KeyValue<K, V1>>;

package/dist/cjs/operators/groupBy.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"groupBy.cjs","sources":["../../../src/operators/groupBy.ts"],"sourcesContent":["import { serializeValue } from '../utils.js'\nimport { 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 = Symbol(`original_group_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 = serializeValue(key)\n\n        // Create values object with pre-aggregated values\n        const values: Record<string | symbol, 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<\n          string,\n          Record<string | symbol, unknown>\n        >\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<PropertyKey, 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>(\n  valueExtractor: (value: T) => any = (v) => v,\n): AggregateFunction<T, number, number> {\n  return {\n    // Count only not-null values (the `== null` comparison gives true for both null and undefined)\n    preMap: (data: T) => (valueExtractor(data) == null ? 0 : 1),\n    reduce: (values: Array<[number, number]>) => {\n      let totalCount = 0\n      for (const [nullMultiplier, multiplicity] of values) {\n        totalCount += nullMultiplier * 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\ntype CanMinMax = number | Date | bigint | string\n\n/**\n * Creates a min aggregate function that computes the minimum value in a group\n * @param valueExtractor Function to extract a comparable value from each data entry\n */\nexport function min<T extends CanMinMax>(): AggregateFunction<\n  T,\n  T | undefined,\n  T | undefined\n>\nexport function min<T, V extends CanMinMax>(\n  valueExtractor: (value: T) => V,\n): AggregateFunction<T, V | undefined, V | undefined>\nexport function min<T, V extends CanMinMax>(\n  valueExtractor?: (value: T) => V,\n): AggregateFunction<T, V | undefined, V | undefined> {\n  const extractor = valueExtractor ?? ((v: T) => v as unknown as V)\n  return {\n    preMap: (data: T) => extractor(data),\n    reduce: (values) => {\n      let minValue: V | undefined\n      for (const [value, _multiplicity] of values) {\n        if (\n          value !== undefined &&\n          (minValue === undefined || value < minValue)\n        ) {\n          minValue = value\n        }\n      }\n      return 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 comparable value from each data entry\n */\nexport function max<T extends CanMinMax>(): AggregateFunction<\n  T,\n  T | undefined,\n  T | undefined\n>\nexport function max<T, V extends CanMinMax>(\n  valueExtractor: (value: T) => V,\n): AggregateFunction<T, V | undefined, V | undefined>\nexport function max<T, V extends CanMinMax>(\n  valueExtractor?: (value: T) => V,\n): AggregateFunction<T, V | undefined, V | undefined> {\n  const extractor = valueExtractor ?? ((v: T) => v as unknown as V)\n  return {\n    preMap: (data: T) => extractor(data),\n    reduce: (values) => {\n      let maxValue: V | undefined\n      for (const [value, _multiplicity] of values) {\n        if (\n          value !== undefined &&\n          (maxValue === undefined || value > maxValue)\n        ) {\n          maxValue = value\n        }\n      }\n      return 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":["map","serializeValue","reduce"],"mappings":"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"}
+{"version":3,"file":"groupBy.cjs","sources":["../../../src/operators/groupBy.ts"],"sourcesContent":["import { serializeValue } from '../utils.js'\nimport { 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> | 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 = Symbol(`original_group_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 = serializeValue(key)\n\n        // Create values object with pre-aggregated values\n        const values: Record<string | symbol, 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<\n          string,\n          Record<string | symbol, unknown>\n        >\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<PropertyKey, 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>(\n  valueExtractor: (value: T) => any = (v) => v,\n): AggregateFunction<T, number, number> {\n  return {\n    // Count only not-null values (the `== null` comparison gives true for both null and undefined)\n    preMap: (data: T) => (valueExtractor(data) == null ? 0 : 1),\n    reduce: (values: Array<[number, number]>) => {\n      let totalCount = 0\n      for (const [nullMultiplier, multiplicity] of values) {\n        totalCount += nullMultiplier * 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\ntype CanMinMax = number | Date | bigint | string\n\n/**\n * Creates a min aggregate function that computes the minimum value in a group\n * @param valueExtractor Function to extract a comparable value from each data entry\n */\nexport function min<T extends CanMinMax>(): AggregateFunction<\n  T,\n  T | undefined,\n  T | undefined\n>\nexport function min<T, V extends CanMinMax>(\n  valueExtractor: (value: T) => V,\n): AggregateFunction<T, V | undefined, V | undefined>\nexport function min<T, V extends CanMinMax>(\n  valueExtractor?: (value: T) => V,\n): AggregateFunction<T, V | undefined, V | undefined> {\n  const extractor = valueExtractor ?? ((v: T) => v as unknown as V)\n  return {\n    preMap: (data: T) => extractor(data),\n    reduce: (values) => {\n      let minValue: V | undefined\n      for (const [value, _multiplicity] of values) {\n        if (\n          value !== undefined &&\n          (minValue === undefined || value < minValue)\n        ) {\n          minValue = value\n        }\n      }\n      return 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 comparable value from each data entry\n */\nexport function max<T extends CanMinMax>(): AggregateFunction<\n  T,\n  T | undefined,\n  T | undefined\n>\nexport function max<T, V extends CanMinMax>(\n  valueExtractor: (value: T) => V,\n): AggregateFunction<T, V | undefined, V | undefined>\nexport function max<T, V extends CanMinMax>(\n  valueExtractor?: (value: T) => V,\n): AggregateFunction<T, V | undefined, V | undefined> {\n  const extractor = valueExtractor ?? ((v: T) => v as unknown as V)\n  return {\n    preMap: (data: T) => extractor(data),\n    reduce: (values) => {\n      let maxValue: V | undefined\n      for (const [value, _multiplicity] of values) {\n        if (\n          value !== undefined &&\n          (maxValue === undefined || value > maxValue)\n        ) {\n          maxValue = value\n        }\n      }\n      return 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":["map","serializeValue","reduce"],"mappings":"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"}

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

@@ -1,8 +1,11 @@
-import { IStreamBuilder, KeyValue } from '../types.js';
+import { IStreamBuilder, KeyValue } from "../types.cjs";
 type GroupKey = Record<string, unknown>;
 type BasicAggregateFunction<T, R, V = unknown> = {
     preMap: (data: T) => V;
-    reduce: (values: Array<[V, number]>) => V;
+    reduce: (values: Array<[
+        V,
+        number
+    ]>) => V;
     postMap?: (result: V) => R;
 };
 type PipedAggregateFunction<T, R> = {

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

@@ -1,4 +1,4 @@
-import { IStreamBuilder, KeyValue } from '../types.js';
+import { IStreamBuilder, KeyValue } from "../types.cjs";
 export interface GroupedOrderByOptions<Ve> {
     comparator?: (a: Ve, b: Ve) => number;
     limit?: number;
@@ -28,4 +28,10 @@ export interface GroupedOrderByWithFractionalIndexOptions<Ve, KeyType = unknown,
  * @param options - Configuration including groupKeyFn, comparator, limit, and offset
  * @returns A piped operator that orders the elements per group and limits the number of results per group
  */
-export declare function groupedOrderByWithFractionalIndex<T extends KeyValue<unknown, unknown>, Ve = unknown>(valueExtractor: (value: T extends KeyValue<unknown, infer V> ? V : never) => Ve, options: GroupedOrderByWithFractionalIndexOptions<Ve, T extends KeyValue<infer K, unknown> ? K : never, T extends KeyValue<unknown, infer V> ? V : never>): (stream: IStreamBuilder<T>) => IStreamBuilder<[T extends KeyValue<infer K, unknown> ? K : never, [T extends KeyValue<unknown, infer V> ? V : never, string]]>;
+export declare function groupedOrderByWithFractionalIndex<T extends KeyValue<unknown, unknown>, Ve = unknown>(valueExtractor: (value: T extends KeyValue<unknown, infer V> ? V : never) => Ve, options: GroupedOrderByWithFractionalIndexOptions<Ve, T extends KeyValue<infer K, unknown> ? K : never, T extends KeyValue<unknown, infer V> ? V : never>): (stream: IStreamBuilder<T>) => IStreamBuilder<[
+    T extends KeyValue<infer K, unknown> ? K : never,
+    [
+        T extends KeyValue<unknown, infer V> ? V : never,
+        string
+    ]
+]>;

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

@@ -1,6 +1,6 @@
-import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from '../graph.js';
-import { IndexedValue, TopK } from './topKArray.js';
-import { PipedOperator } from '../types.js';
+import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from "../graph.cjs";
+import { IndexedValue, TopK } from "./topKArray.cjs";
+import { PipedOperator } from "../types.cjs";
 export interface GroupedTopKWithFractionalIndexOptions<K, T> {
     limit?: number;
     offset?: number;
@@ -24,14 +24,35 @@ export interface GroupedTopKWithFractionalIndexOptions<K, T> {
  * Elements are grouped by the groupKeyFn, and each group maintains
  * its own sorted collection with independent limit/offset.
  */
-export declare class GroupedTopKWithFractionalIndexOperator<K extends string | number, T> extends UnaryOperator<[K, T], [K, IndexedValue<T>]> {
+export declare class GroupedTopKWithFractionalIndexOperator<K extends string | number, T> extends UnaryOperator<[
+    K,
+    T
+], [
+    K,
+    IndexedValue<T>
+]> {
     #private;
-    constructor(id: number, inputA: DifferenceStreamReader<[K, T]>, output: DifferenceStreamWriter<[K, IndexedValue<T>]>, comparator: (a: T, b: T) => number, options: GroupedTopKWithFractionalIndexOptions<K, T>);
+    constructor(id: number, inputA: DifferenceStreamReader<[
+        K,
+        T
+    ]>, output: DifferenceStreamWriter<[
+        K,
+        IndexedValue<T>
+    ]>, comparator: (a: T, b: T) => number, options: GroupedTopKWithFractionalIndexOptions<K, T>);
     /**
      * Creates a new TopK data structure for a group.
      * Can be overridden in subclasses to use different implementations (e.g., B+ tree).
      */
-    protected createTopK(offset: number, limit: number, comparator: (a: [K, T], b: [K, T]) => number): TopK<[K, T]>;
+    protected createTopK(offset: number, limit: number, comparator: (a: [
+        K,
+        T
+    ], b: [
+        K,
+        T
+    ]) => number): TopK<[
+        K,
+        T
+    ]>;
     run(): void;
 }
 /**
@@ -47,4 +68,10 @@ export declare class GroupedTopKWithFractionalIndexOperator<K extends string | n
  * @param options - Configuration including groupKeyFn, limit, and offset
  * @returns A piped operator that orders elements per group and limits results per group
  */
-export declare function groupedTopKWithFractionalIndex<K extends string | number, T>(comparator: (a: T, b: T) => number, options: GroupedTopKWithFractionalIndexOptions<K, T>): PipedOperator<[K, T], [K, IndexedValue<T>]>;
+export declare function groupedTopKWithFractionalIndex<K extends string | number, T>(comparator: (a: T, b: T) => number, options: GroupedTopKWithFractionalIndexOptions<K, T>): PipedOperator<[
+    K,
+    T
+], [
+    K,
+    IndexedValue<T>
+]>;

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

@@ -1,21 +1,21 @@
-export * from './pipe.js';
-export * from './map.js';
-export * from './tap.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 './groupedTopKWithFractionalIndex.js';
-export * from './orderBy.js';
-export * from './groupedOrderBy.js';
-export * from './filterBy.js';
-export { groupBy, groupByOperators } from './groupBy.js';
+export * from "./pipe.cjs";
+export * from "./map.cjs";
+export * from "./tap.cjs";
+export * from "./filter.cjs";
+export * from "./negate.cjs";
+export * from "./concat.cjs";
+export * from "./debug.cjs";
+export * from "./output.cjs";
+export * from "./consolidate.cjs";
+export * from "./join.cjs";
+export * from "./reduce.cjs";
+export * from "./count.cjs";
+export * from "./distinct.cjs";
+export * from "./keying.cjs";
+export * from "./topK.cjs";
+export * from "./topKWithFractionalIndex.cjs";
+export * from "./groupedTopKWithFractionalIndex.cjs";
+export * from "./orderBy.cjs";
+export * from "./groupedOrderBy.cjs";
+export * from "./filterBy.cjs";
+export { groupBy, groupByOperators } from "./groupBy.cjs";