@tanstack/db-ivm 0.1.26 → 0.2.0

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

@@ -1 +0,0 @@
-{"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,9 +0,0 @@
-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,
- * such as a streams of issues and comments for a project.
- *
- * @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>>;

package/dist/cjs/operators/keying.cjs

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const map = require("./map.cjs");
-function keyBy(keyFn) {
-  return map.map((value) => [keyFn(value), value]);
-}
-function unkey() {
-  return map.map(([_, value]) => value);
-}
-function rekey(keyFn) {
-  return map.map(([_, value]) => [keyFn(value), value]);
-}
-exports.keyBy = keyBy;
-exports.rekey = rekey;
-exports.unkey = unkey;
-//# sourceMappingURL=keying.cjs.map

package/dist/cjs/operators/keying.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"keying.cjs","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":["map"],"mappings":";;;AAYO,SAAS,MACd,OAC+B;AAC/B,SAAOA,IAAAA,IAAI,CAAC,UAA0B,CAAC,MAAM,KAAK,GAAG,KAAK,CAAC;AAC7D;AAKO,SAAS,QAA6C;AAC3D,SAAOA,IAAAA,IAAI,CAAC,CAAC,GAAG,KAAK,MAAsB,KAAK;AAClD;AAMO,SAAS,MACd,OAC2C;AAC3C,SAAOA,IAAAA,IAAI,CAAC,CAAC,GAAG,KAAK,MAAkC,CAAC,MAAM,KAAK,GAAG,KAAK,CAAC;AAC9E;;;;"}

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

@@ -1,22 +0,0 @@
-import { PipedOperator } from "../types.cjs";
-/**
- * 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/cjs/operators/negate.cjs

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const graph = require("../graph.cjs");
-const d2 = require("../d2.cjs");
-class NegateOperator extends graph.LinearUnaryOperator {
-  inner(collection) {
-    return collection.negate();
-  }
-}
-function negate() {
-  return (stream) => {
-    const output = new d2.StreamBuilder(
-      stream.graph,
-      new graph.DifferenceStreamWriter()
-    );
-    const operator = new NegateOperator(
-      stream.graph.getNextOperatorId(),
-      stream.connectReader(),
-      output.writer
-    );
-    stream.graph.addOperator(operator);
-    return output;
-  };
-}
-exports.NegateOperator = NegateOperator;
-exports.negate = negate;
-//# sourceMappingURL=negate.cjs.map

package/dist/cjs/operators/negate.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"negate.cjs","sources":["../../../src/operators/negate.ts"],"sourcesContent":["import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'\nimport { StreamBuilder } from '../d2.js'\nimport type { IStreamBuilder, PipedOperator } from '../types.js'\nimport type { MultiSet } from '../multiset.js'\n\n/**\n * Operator that negates the multiplicities in the input stream\n */\nexport class NegateOperator<T> extends LinearUnaryOperator<T, T> {\n  inner(collection: MultiSet<T>): MultiSet<T> {\n    return collection.negate()\n  }\n}\n\n/**\n * Negates the multiplicities in the input stream\n */\nexport function negate<T>(): PipedOperator<T, T> {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const output = new StreamBuilder<T>(\n      stream.graph,\n      new DifferenceStreamWriter<T>(),\n    )\n    const operator = new NegateOperator<T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      output.writer,\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":["LinearUnaryOperator","StreamBuilder","DifferenceStreamWriter"],"mappings":";;;;AAQO,MAAM,uBAA0BA,MAAAA,oBAA0B;AAAA,EAC/D,MAAM,YAAsC;AAC1C,WAAO,WAAW,OAAA;AAAA,EACpB;AACF;AAKO,SAAS,SAAiC;AAC/C,SAAO,CAAC,WAAiD;AACvD,UAAM,SAAS,IAAIC,GAAAA;AAAAA,MACjB,OAAO;AAAA,MACP,IAAIC,MAAAA,uBAAA;AAAA,IAA0B;AAEhC,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,OAAO;AAAA,IAAA;AAET,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;;;"}

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

@@ -1,13 +0,0 @@
-import { LinearUnaryOperator } from "../graph.cjs";
-import { PipedOperator } from "../types.cjs";
-import { MultiSet } from "../multiset.cjs";
-/**
- * Operator that negates the multiplicities in the input stream
- */
-export declare class NegateOperator<T> extends LinearUnaryOperator<T, T> {
-    inner(collection: MultiSet<T>): MultiSet<T>;
-}
-/**
- * Negates the multiplicities in the input stream
- */
-export declare function negate<T>(): PipedOperator<T, T>;

package/dist/cjs/operators/topK.cjs

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const multiset = require("../multiset.cjs");
-const reduce = require("./reduce.cjs");
-function topK(comparator, options) {
-  const limit = options?.limit ?? Infinity;
-  const offset = options?.offset ?? 0;
-  return (stream) => {
-    const reduced = stream.pipe(
-      reduce.reduce((values) => {
-        const consolidated = new multiset.MultiSet(values).consolidate();
-        const sortedValues = consolidated.getInner().sort((a, b) => comparator(a[0], b[0]));
-        return sortedValues.slice(offset, offset + limit);
-      })
-    );
-    return reduced;
-  };
-}
-function topKWithIndex(comparator, options) {
-  const limit = options?.limit ?? Infinity;
-  const offset = options?.offset ?? 0;
-  return (stream) => {
-    const reduced = stream.pipe(
-      reduce.reduce((values) => {
-        const consolidated = new multiset.MultiSet(values).consolidate();
-        let i = offset;
-        const sortedValues = consolidated.getInner().sort((a, b) => comparator(a[0], b[0])).slice(offset, offset + limit).map(([value, multiplicity]) => [
-          [value, i++],
-          multiplicity
-        ]);
-        return sortedValues;
-      })
-    );
-    return reduced;
-  };
-}
-exports.topK = topK;
-exports.topKWithIndex = topKWithIndex;
-//# sourceMappingURL=topK.cjs.map

package/dist/cjs/operators/topK.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"topK.cjs","sources":["../../../src/operators/topK.ts"],"sourcesContent":["import { MultiSet } from '../multiset.js'\nimport { reduce } from './reduce.js'\nimport type { IStreamBuilder, KeyValue, PipedOperator } from '../types'\n\ninterface TopKOptions {\n  limit?: number\n  offset?: number\n}\n\n/**\n * Limits the number of results based on a comparator, with optional offset.\n * This works on a keyed stream, where the key is the first element of the tuple\n * The ordering is withing a key group, i.e. elements are sorted within a key group\n * and the limit + offset is applied to that sorted group.\n * To order the entire stream, key by the same value for all elements such as null.\n *\n * @param comparator - A function that compares two elements\n * @param options - An optional object containing limit and offset properties\n * @returns A piped operator that limits the number of results\n */\nexport function topK<\n  KType extends (T extends KeyValue<infer K, infer _V> ? K : never),\n  V1Type extends (T extends KeyValue<KType, infer V> ? V : never),\n  T,\n>(\n  comparator: (a: V1Type, b: V1Type) => number,\n  options?: TopKOptions,\n): PipedOperator<T, T> {\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const reduced = stream.pipe(\n      reduce((values) => {\n        // `values` is a list of tuples, first element is the value, second is the multiplicity\n        const consolidated = new MultiSet(values).consolidate()\n        const sortedValues = consolidated\n          .getInner()\n          .sort((a, b) => comparator(a[0] as V1Type, b[0] as V1Type))\n        return sortedValues.slice(offset, offset + limit)\n      }),\n    )\n    return reduced as IStreamBuilder<T>\n  }\n}\n\n/**\n * Limits the number of results based on a comparator, with optional offset.\n * This works on a keyed stream, where the key is the first element of the tuple\n * The ordering is withing a key group, i.e. elements are sorted within a key group\n * and the limit + offset is applied to that sorted group.\n * To order the entire stream, key by the same value for all elements such as null.\n * Adds the index of the element to the result as [key, [value, index]]\n *\n * @param comparator - A function that compares two elements\n * @param options - An optional object containing limit and offset properties\n * @returns A piped operator that orders the elements and limits the number of results\n */\nexport function topKWithIndex<\n  KType extends (T extends KeyValue<infer K, infer _V> ? K : never),\n  V1Type extends (T extends KeyValue<KType, infer V> ? V : never),\n  T,\n>(\n  comparator: (a: V1Type, b: V1Type) => number,\n  options?: TopKOptions,\n): PipedOperator<T, KeyValue<KType, [V1Type, number]>> {\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n\n  return (\n    stream: IStreamBuilder<T>,\n  ): IStreamBuilder<KeyValue<KType, [V1Type, number]>> => {\n    const reduced = stream.pipe(\n      reduce<KType, V1Type, [V1Type, number], T>((values) => {\n        // `values` is a list of tuples, first element is the value, second is the multiplicity\n        const consolidated = new MultiSet(values).consolidate()\n        let i = offset\n        const sortedValues = consolidated\n          .getInner()\n          .sort((a, b) => comparator(a[0], b[0]))\n          .slice(offset, offset + limit)\n          .map(([value, multiplicity]): [[V1Type, number], number] => [\n            [value, i++],\n            multiplicity,\n          ])\n        return sortedValues\n      }),\n    )\n    return reduced\n  }\n}\n"],"names":["reduce","MultiSet"],"mappings":";;;;AAoBO,SAAS,KAKd,YACA,SACqB;AACrB,QAAM,QAAQ,SAAS,SAAS;AAChC,QAAM,SAAS,SAAS,UAAU;AAElC,SAAO,CAAC,WAAiD;AACvD,UAAM,UAAU,OAAO;AAAA,MACrBA,OAAAA,OAAO,CAAC,WAAW;AAEjB,cAAM,eAAe,IAAIC,SAAAA,SAAS,MAAM,EAAE,YAAA;AAC1C,cAAM,eAAe,aAClB,SAAA,EACA,KAAK,CAAC,GAAG,MAAM,WAAW,EAAE,CAAC,GAAa,EAAE,CAAC,CAAW,CAAC;AAC5D,eAAO,aAAa,MAAM,QAAQ,SAAS,KAAK;AAAA,MAClD,CAAC;AAAA,IAAA;AAEH,WAAO;AAAA,EACT;AACF;AAcO,SAAS,cAKd,YACA,SACqD;AACrD,QAAM,QAAQ,SAAS,SAAS;AAChC,QAAM,SAAS,SAAS,UAAU;AAElC,SAAO,CACL,WACsD;AACtD,UAAM,UAAU,OAAO;AAAA,MACrBD,OAAAA,OAA2C,CAAC,WAAW;AAErD,cAAM,eAAe,IAAIC,SAAAA,SAAS,MAAM,EAAE,YAAA;AAC1C,YAAI,IAAI;AACR,cAAM,eAAe,aAClB,SAAA,EACA,KAAK,CAAC,GAAG,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EACrC,MAAM,QAAQ,SAAS,KAAK,EAC5B,IAAI,CAAC,CAAC,OAAO,YAAY,MAAkC;AAAA,UAC1D,CAAC,OAAO,GAAG;AAAA,UACX;AAAA,QAAA,CACD;AACH,eAAO;AAAA,MACT,CAAC;AAAA,IAAA;AAEH,WAAO;AAAA,EACT;AACF;;;"}

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

@@ -1,34 +0,0 @@
-import { KeyValue, PipedOperator } from '../types.cjs';
-interface TopKOptions {
-    limit?: number;
-    offset?: number;
-}
-/**
- * Limits the number of results based on a comparator, with optional offset.
- * This works on a keyed stream, where the key is the first element of the tuple
- * The ordering is withing a key group, i.e. elements are sorted within a key group
- * and the limit + offset is applied to that sorted group.
- * To order the entire stream, key by the same value for all elements such as null.
- *
- * @param comparator - A function that compares two elements
- * @param options - An optional object containing limit and offset properties
- * @returns A piped operator that limits the number of results
- */
-export declare function topK<KType extends (T extends KeyValue<infer K, infer _V> ? K : never), V1Type extends (T extends KeyValue<KType, infer V> ? V : never), T>(comparator: (a: V1Type, b: V1Type) => number, options?: TopKOptions): PipedOperator<T, T>;
-/**
- * Limits the number of results based on a comparator, with optional offset.
- * This works on a keyed stream, where the key is the first element of the tuple
- * The ordering is withing a key group, i.e. elements are sorted within a key group
- * and the limit + offset is applied to that sorted group.
- * To order the entire stream, key by the same value for all elements such as null.
- * Adds the index of the element to the result as [key, [value, index]]
- *
- * @param comparator - A function that compares two elements
- * @param options - An optional object containing limit and offset properties
- * @returns A piped operator that orders the elements and limits the number of results
- */
-export declare function topKWithIndex<KType extends (T extends KeyValue<infer K, infer _V> ? K : never), V1Type extends (T extends KeyValue<KType, infer V> ? V : never), T>(comparator: (a: V1Type, b: V1Type) => number, options?: TopKOptions): PipedOperator<T, KeyValue<KType, [
-    V1Type,
-    number
-]>>;
-export {};

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

@@ -1,43 +0,0 @@
-import { TopKWithFractionalIndexOperator, TopKWithFractionalIndexOptions } from "./topKWithFractionalIndex.cjs";
-import { IndexedValue, TopK } from "./topKArray.cjs";
-import { PipedOperator } from "../types.cjs";
-export declare function loadBTree(): Promise<void>;
-/**
- * Operator for fractional indexed topK operations
- * This operator maintains fractional indices for sorted elements
- * and only updates indices when elements move position
- */
-export declare class TopKWithFractionalIndexBTreeOperator<K extends string | number, T> extends TopKWithFractionalIndexOperator<K, T> {
-    protected createTopK(offset: number, limit: number, comparator: (a: [
-        K,
-        T
-    ], b: [
-        K,
-        T
-    ]) => number): TopK<[
-        K,
-        T
-    ]>;
-}
-/**
- * Limits the number of results based on a comparator, with optional offset.
- * This works on a keyed stream, where the key is the first element of the tuple.
- * The ordering is within a key group, i.e. elements are sorted within a key group
- * and the limit + offset is applied to that sorted group.
- * To order the entire stream, key by the same value for all elements such as null.
- *
- * Uses fractional indexing to minimize the number of changes when elements move positions.
- * Each element is assigned a fractional index that is lexicographically sortable.
- * When elements move, only the indices of the moved elements are updated, not all elements.
- *
- * @param comparator - A function that compares two elements
- * @param options - An optional object containing limit and offset properties
- * @returns A piped operator that orders the elements and limits the number of results
- */
-export declare function topKWithFractionalIndexBTree<KType extends string | number, T>(comparator: (a: T, b: T) => number, options?: TopKWithFractionalIndexOptions): PipedOperator<[
-    KType,
-    T
-], [
-    KType,
-    IndexedValue<T>
-]>;

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

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

package/dist/esm/operators/count.js

@@ -1,35 +0,0 @@
-import { DifferenceStreamWriter } from "../graph.js";
-import { StreamBuilder } from "../d2.js";
-import { ReduceOperator } from "./reduce.js";
-class CountOperator extends ReduceOperator {
-  constructor(id, inputA, output) {
-    const countInner = (vals) => {
-      let totalCount = 0;
-      for (const [_, diff] of vals) {
-        totalCount += diff;
-      }
-      return [[totalCount, 1]];
-    };
-    super(id, inputA, output, countInner);
-  }
-}
-function count() {
-  return (stream) => {
-    const output = new StreamBuilder(
-      stream.graph,
-      new DifferenceStreamWriter()
-    );
-    const operator = new CountOperator(
-      stream.graph.getNextOperatorId(),
-      stream.connectReader(),
-      output.writer
-    );
-    stream.graph.addOperator(operator);
-    return output;
-  };
-}
-export {
-  CountOperator,
-  count
-};
-//# sourceMappingURL=count.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"count.js","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":[],"mappings":";;;AASO,MAAM,sBAA4B,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,IAAI;AAAA,MACjB,OAAO;AAAA,MACP,IAAI,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/esm/operators/debug.d.ts

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

package/dist/esm/operators/debug.js

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

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

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

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

@@ -1,9 +0,0 @@
-import { IStreamBuilder, KeyValue, PipedOperator } from '../types.js';
-/**
- * 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,
- * such as a streams of issues and comments for a project.
- *
- * @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>>;

package/dist/esm/operators/filterBy.js

@@ -1,19 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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 { 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":[],"mappings":";;;AAYO,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/keying.d.ts

@@ -1,19 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/negate.d.ts

@@ -1,13 +0,0 @@
-import { LinearUnaryOperator } from '../graph.js';
-import { PipedOperator } from '../types.js';
-import { MultiSet } from '../multiset.js';
-/**
- * Operator that negates the multiplicities in the input stream
- */
-export declare class NegateOperator<T> extends LinearUnaryOperator<T, T> {
-    inner(collection: MultiSet<T>): MultiSet<T>;
-}
-/**
- * Negates the multiplicities in the input stream
- */
-export declare function negate<T>(): PipedOperator<T, T>;

package/dist/esm/operators/negate.js

@@ -1,27 +0,0 @@
-import { LinearUnaryOperator, DifferenceStreamWriter } from "../graph.js";
-import { StreamBuilder } from "../d2.js";
-class NegateOperator extends LinearUnaryOperator {
-  inner(collection) {
-    return collection.negate();
-  }
-}
-function negate() {
-  return (stream) => {
-    const output = new StreamBuilder(
-      stream.graph,
-      new DifferenceStreamWriter()
-    );
-    const operator = new NegateOperator(
-      stream.graph.getNextOperatorId(),
-      stream.connectReader(),
-      output.writer
-    );
-    stream.graph.addOperator(operator);
-    return output;
-  };
-}
-export {
-  NegateOperator,
-  negate
-};
-//# sourceMappingURL=negate.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"negate.js","sources":["../../../src/operators/negate.ts"],"sourcesContent":["import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'\nimport { StreamBuilder } from '../d2.js'\nimport type { IStreamBuilder, PipedOperator } from '../types.js'\nimport type { MultiSet } from '../multiset.js'\n\n/**\n * Operator that negates the multiplicities in the input stream\n */\nexport class NegateOperator<T> extends LinearUnaryOperator<T, T> {\n  inner(collection: MultiSet<T>): MultiSet<T> {\n    return collection.negate()\n  }\n}\n\n/**\n * Negates the multiplicities in the input stream\n */\nexport function negate<T>(): PipedOperator<T, T> {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const output = new StreamBuilder<T>(\n      stream.graph,\n      new DifferenceStreamWriter<T>(),\n    )\n    const operator = new NegateOperator<T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      output.writer,\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":[],"mappings":";;AAQO,MAAM,uBAA0B,oBAA0B;AAAA,EAC/D,MAAM,YAAsC;AAC1C,WAAO,WAAW,OAAA;AAAA,EACpB;AACF;AAKO,SAAS,SAAiC;AAC/C,SAAO,CAAC,WAAiD;AACvD,UAAM,SAAS,IAAI;AAAA,MACjB,OAAO;AAAA,MACP,IAAI,uBAAA;AAAA,IAA0B;AAEhC,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,OAAO;AAAA,IAAA;AAET,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;"}

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

@@ -1,31 +0,0 @@
-import { KeyValue, PipedOperator } from '../types.js';
-interface TopKOptions {
-    limit?: number;
-    offset?: number;
-}
-/**
- * Limits the number of results based on a comparator, with optional offset.
- * This works on a keyed stream, where the key is the first element of the tuple
- * The ordering is withing a key group, i.e. elements are sorted within a key group
- * and the limit + offset is applied to that sorted group.
- * To order the entire stream, key by the same value for all elements such as null.
- *
- * @param comparator - A function that compares two elements
- * @param options - An optional object containing limit and offset properties
- * @returns A piped operator that limits the number of results
- */
-export declare function topK<KType extends (T extends KeyValue<infer K, infer _V> ? K : never), V1Type extends (T extends KeyValue<KType, infer V> ? V : never), T>(comparator: (a: V1Type, b: V1Type) => number, options?: TopKOptions): PipedOperator<T, T>;
-/**
- * Limits the number of results based on a comparator, with optional offset.
- * This works on a keyed stream, where the key is the first element of the tuple
- * The ordering is withing a key group, i.e. elements are sorted within a key group
- * and the limit + offset is applied to that sorted group.
- * To order the entire stream, key by the same value for all elements such as null.
- * Adds the index of the element to the result as [key, [value, index]]
- *
- * @param comparator - A function that compares two elements
- * @param options - An optional object containing limit and offset properties
- * @returns A piped operator that orders the elements and limits the number of results
- */
-export declare function topKWithIndex<KType extends (T extends KeyValue<infer K, infer _V> ? K : never), V1Type extends (T extends KeyValue<KType, infer V> ? V : never), T>(comparator: (a: V1Type, b: V1Type) => number, options?: TopKOptions): PipedOperator<T, KeyValue<KType, [V1Type, number]>>;
-export {};

package/dist/esm/operators/topK.js

@@ -1,39 +0,0 @@
-import { MultiSet } from "../multiset.js";
-import { reduce } from "./reduce.js";
-function topK(comparator, options) {
-  const limit = options?.limit ?? Infinity;
-  const offset = options?.offset ?? 0;
-  return (stream) => {
-    const reduced = stream.pipe(
-      reduce((values) => {
-        const consolidated = new MultiSet(values).consolidate();
-        const sortedValues = consolidated.getInner().sort((a, b) => comparator(a[0], b[0]));
-        return sortedValues.slice(offset, offset + limit);
-      })
-    );
-    return reduced;
-  };
-}
-function topKWithIndex(comparator, options) {
-  const limit = options?.limit ?? Infinity;
-  const offset = options?.offset ?? 0;
-  return (stream) => {
-    const reduced = stream.pipe(
-      reduce((values) => {
-        const consolidated = new MultiSet(values).consolidate();
-        let i = offset;
-        const sortedValues = consolidated.getInner().sort((a, b) => comparator(a[0], b[0])).slice(offset, offset + limit).map(([value, multiplicity]) => [
-          [value, i++],
-          multiplicity
-        ]);
-        return sortedValues;
-      })
-    );
-    return reduced;
-  };
-}
-export {
-  topK,
-  topKWithIndex
-};
-//# sourceMappingURL=topK.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"topK.js","sources":["../../../src/operators/topK.ts"],"sourcesContent":["import { MultiSet } from '../multiset.js'\nimport { reduce } from './reduce.js'\nimport type { IStreamBuilder, KeyValue, PipedOperator } from '../types'\n\ninterface TopKOptions {\n  limit?: number\n  offset?: number\n}\n\n/**\n * Limits the number of results based on a comparator, with optional offset.\n * This works on a keyed stream, where the key is the first element of the tuple\n * The ordering is withing a key group, i.e. elements are sorted within a key group\n * and the limit + offset is applied to that sorted group.\n * To order the entire stream, key by the same value for all elements such as null.\n *\n * @param comparator - A function that compares two elements\n * @param options - An optional object containing limit and offset properties\n * @returns A piped operator that limits the number of results\n */\nexport function topK<\n  KType extends (T extends KeyValue<infer K, infer _V> ? K : never),\n  V1Type extends (T extends KeyValue<KType, infer V> ? V : never),\n  T,\n>(\n  comparator: (a: V1Type, b: V1Type) => number,\n  options?: TopKOptions,\n): PipedOperator<T, T> {\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const reduced = stream.pipe(\n      reduce((values) => {\n        // `values` is a list of tuples, first element is the value, second is the multiplicity\n        const consolidated = new MultiSet(values).consolidate()\n        const sortedValues = consolidated\n          .getInner()\n          .sort((a, b) => comparator(a[0] as V1Type, b[0] as V1Type))\n        return sortedValues.slice(offset, offset + limit)\n      }),\n    )\n    return reduced as IStreamBuilder<T>\n  }\n}\n\n/**\n * Limits the number of results based on a comparator, with optional offset.\n * This works on a keyed stream, where the key is the first element of the tuple\n * The ordering is withing a key group, i.e. elements are sorted within a key group\n * and the limit + offset is applied to that sorted group.\n * To order the entire stream, key by the same value for all elements such as null.\n * Adds the index of the element to the result as [key, [value, index]]\n *\n * @param comparator - A function that compares two elements\n * @param options - An optional object containing limit and offset properties\n * @returns A piped operator that orders the elements and limits the number of results\n */\nexport function topKWithIndex<\n  KType extends (T extends KeyValue<infer K, infer _V> ? K : never),\n  V1Type extends (T extends KeyValue<KType, infer V> ? V : never),\n  T,\n>(\n  comparator: (a: V1Type, b: V1Type) => number,\n  options?: TopKOptions,\n): PipedOperator<T, KeyValue<KType, [V1Type, number]>> {\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n\n  return (\n    stream: IStreamBuilder<T>,\n  ): IStreamBuilder<KeyValue<KType, [V1Type, number]>> => {\n    const reduced = stream.pipe(\n      reduce<KType, V1Type, [V1Type, number], T>((values) => {\n        // `values` is a list of tuples, first element is the value, second is the multiplicity\n        const consolidated = new MultiSet(values).consolidate()\n        let i = offset\n        const sortedValues = consolidated\n          .getInner()\n          .sort((a, b) => comparator(a[0], b[0]))\n          .slice(offset, offset + limit)\n          .map(([value, multiplicity]): [[V1Type, number], number] => [\n            [value, i++],\n            multiplicity,\n          ])\n        return sortedValues\n      }),\n    )\n    return reduced\n  }\n}\n"],"names":[],"mappings":";;AAoBO,SAAS,KAKd,YACA,SACqB;AACrB,QAAM,QAAQ,SAAS,SAAS;AAChC,QAAM,SAAS,SAAS,UAAU;AAElC,SAAO,CAAC,WAAiD;AACvD,UAAM,UAAU,OAAO;AAAA,MACrB,OAAO,CAAC,WAAW;AAEjB,cAAM,eAAe,IAAI,SAAS,MAAM,EAAE,YAAA;AAC1C,cAAM,eAAe,aAClB,SAAA,EACA,KAAK,CAAC,GAAG,MAAM,WAAW,EAAE,CAAC,GAAa,EAAE,CAAC,CAAW,CAAC;AAC5D,eAAO,aAAa,MAAM,QAAQ,SAAS,KAAK;AAAA,MAClD,CAAC;AAAA,IAAA;AAEH,WAAO;AAAA,EACT;AACF;AAcO,SAAS,cAKd,YACA,SACqD;AACrD,QAAM,QAAQ,SAAS,SAAS;AAChC,QAAM,SAAS,SAAS,UAAU;AAElC,SAAO,CACL,WACsD;AACtD,UAAM,UAAU,OAAO;AAAA,MACrB,OAA2C,CAAC,WAAW;AAErD,cAAM,eAAe,IAAI,SAAS,MAAM,EAAE,YAAA;AAC1C,YAAI,IAAI;AACR,cAAM,eAAe,aAClB,SAAA,EACA,KAAK,CAAC,GAAG,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EACrC,MAAM,QAAQ,SAAS,KAAK,EAC5B,IAAI,CAAC,CAAC,OAAO,YAAY,MAAkC;AAAA,UAC1D,CAAC,OAAO,GAAG;AAAA,UACX;AAAA,QAAA,CACD;AACH,eAAO;AAAA,MACT,CAAC;AAAA,IAAA;AAEH,WAAO;AAAA,EACT;AACF;"}

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

@@ -1,28 +0,0 @@
-import { TopKWithFractionalIndexOperator, TopKWithFractionalIndexOptions } from './topKWithFractionalIndex.js';
-import { IndexedValue, TopK } from './topKArray.js';
-import { PipedOperator } from '../types.js';
-export declare function loadBTree(): Promise<void>;
-/**
- * Operator for fractional indexed topK operations
- * This operator maintains fractional indices for sorted elements
- * and only updates indices when elements move position
- */
-export declare class TopKWithFractionalIndexBTreeOperator<K extends string | number, T> extends TopKWithFractionalIndexOperator<K, T> {
-    protected createTopK(offset: number, limit: number, comparator: (a: [K, T], b: [K, T]) => number): TopK<[K, T]>;
-}
-/**
- * Limits the number of results based on a comparator, with optional offset.
- * This works on a keyed stream, where the key is the first element of the tuple.
- * The ordering is within a key group, i.e. elements are sorted within a key group
- * and the limit + offset is applied to that sorted group.
- * To order the entire stream, key by the same value for all elements such as null.
- *
- * Uses fractional indexing to minimize the number of changes when elements move positions.
- * Each element is assigned a fractional index that is lexicographically sortable.
- * When elements move, only the indices of the moved elements are updated, not all elements.
- *
- * @param comparator - A function that compares two elements
- * @param options - An optional object containing limit and offset properties
- * @returns A piped operator that orders the elements and limits the number of results
- */
-export declare function topKWithFractionalIndexBTree<KType extends string | number, T>(comparator: (a: T, b: T) => number, options?: TopKWithFractionalIndexOptions): PipedOperator<[KType, T], [KType, IndexedValue<T>]>;