@tanstack/db-ivm 0.1.13 → 0.1.14

package/src/operators/groupBy.ts

@@ -1,6 +1,6 @@
-import { map } from "./map.js"
-import { reduce } from "./reduce.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { map } from './map.js'
+import { reduce } from './reduce.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 type GroupKey = Record<string, unknown>
 
@@ -26,7 +26,7 @@ type AggregatesReturnType<T, A> = {
 }
 
 function isPipedAggregateFunction<T, R>(
-  aggregate: AggregateFunction<T, R>
+  aggregate: AggregateFunction<T, R>,
 ): aggregate is PipedAggregateFunction<T, R> {
   return `pipe` in aggregate
 }
@@ -45,20 +45,20 @@ export function groupBy<
 
   const basicAggregates = Object.fromEntries(
     Object.entries(aggregates).filter(
-      ([_, aggregate]) => !isPipedAggregateFunction(aggregate)
-    )
+      ([_, aggregate]) => !isPipedAggregateFunction(aggregate),
+    ),
   ) as Record<string, BasicAggregateFunction<T, any, any>>
 
   // @ts-expect-error - TODO: we don't use this yet, but we will
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const pipedAggregates = Object.fromEntries(
     Object.entries(aggregates).filter(([_, aggregate]) =>
-      isPipedAggregateFunction(aggregate)
-    )
+      isPipedAggregateFunction(aggregate),
+    ),
   ) as Record<string, PipedAggregateFunction<T, any>>
 
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<KeyValue<string, ResultType>> => {
     // Special key to store the original key object
     const KEY_SENTINEL = `__original_key__`
@@ -81,7 +81,7 @@ export function groupBy<
         }
 
         return [keyString, values] as KeyValue<string, Record<string, unknown>>
-      })
+      }),
     )
 
     // Then reduce to compute aggregates
@@ -107,13 +107,13 @@ export function groupBy<
         // Apply each aggregate function
         for (const [name, aggregate] of Object.entries(basicAggregates)) {
           const preValues = values.map(
-            ([v, m]) => [v[name], m] as [any, number]
+            ([v, m]) => [v[name], m] as [any, number],
           )
           result[name] = aggregate.reduce(preValues)
         }
 
         return [[result, 1]]
-      })
+      }),
     )
 
     // Finally map to extract the key and include all values
@@ -139,7 +139,7 @@ export function groupBy<
 
         // Return with the string key instead of the object
         return [keyString, result] as KeyValue<string, ResultType>
-      })
+      }),
     )
   }
 }
@@ -148,7 +148,7 @@ export function groupBy<
  * Creates a sum aggregate function
  */
 export function sum<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, number> {
   return {
     preMap: (data: T) => valueExtractor(data),
@@ -166,7 +166,7 @@ export function sum<T>(
  * Creates a count aggregate function
  */
 export function count<T>(
-  valueExtractor: (value: T) => any = (v) => v
+  valueExtractor: (value: T) => any = (v) => v,
 ): AggregateFunction<T, number, number> {
   return {
     // Count only not-null values (the `== null` comparison gives true for both null and undefined)
@@ -185,7 +185,7 @@ export function count<T>(
  * Creates an average aggregate function
  */
 export function avg<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, { sum: number; count: number }> {
   return {
     preMap: (data: T) => ({
@@ -222,10 +222,10 @@ export function min<T extends CanMinMax>(): AggregateFunction<
   T | undefined
 >
 export function min<T, V extends CanMinMax>(
-  valueExtractor: (value: T) => V
+  valueExtractor: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined>
 export function min<T, V extends CanMinMax>(
-  valueExtractor?: (value: T) => V
+  valueExtractor?: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined> {
   const extractor = valueExtractor ?? ((v: T) => v as unknown as V)
   return {
@@ -252,10 +252,10 @@ export function max<T extends CanMinMax>(): AggregateFunction<
   T | undefined
 >
 export function max<T, V extends CanMinMax>(
-  valueExtractor: (value: T) => V
+  valueExtractor: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined>
 export function max<T, V extends CanMinMax>(
-  valueExtractor?: (value: T) => V
+  valueExtractor?: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined> {
   const extractor = valueExtractor ?? ((v: T) => v as unknown as V)
   return {
@@ -278,7 +278,7 @@ export function max<T, V extends CanMinMax>(
  * @param valueExtractor Function to extract a numeric value from each data entry
  */
 export function median<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, Array<number>> {
   return {
     preMap: (data: T) => [valueExtractor(data)],
@@ -326,7 +326,7 @@ export function median<T>(
  * @param valueExtractor Function to extract a value from each data entry
  */
 export function mode<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, Map<number, number>> {
   return {
     preMap: (data: T) => {

package/src/operators/index.ts

@@ -1,19 +1,19 @@
-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 "./orderBy.js"
-export * from "./filterBy.js"
-export { groupBy, groupByOperators } from "./groupBy.js"
+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 './orderBy.js'
+export * from './filterBy.js'
+export { groupBy, groupByOperators } from './groupBy.js'

package/src/operators/join.ts

@@ -48,12 +48,12 @@
  * - **Bag semantics**: Proper multiplicity handling including negatives
  */
 
-import { BinaryOperator, DifferenceStreamWriter } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { MultiSet } from "../multiset.js"
-import { Index } from "../indexes.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { IStreamBuilder, KeyValue, PipedOperator } from "../types.js"
+import { BinaryOperator, DifferenceStreamWriter } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { MultiSet } from '../multiset.js'
+import { Index } from '../indexes.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, KeyValue, PipedOperator } from '../types.js'
 
 /**
  * Type of join to perform
@@ -75,7 +75,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
     inputA: DifferenceStreamReader<[K, V1]>,
     inputB: DifferenceStreamReader<[K, V2]>,
     output: DifferenceStreamWriter<any>,
-    mode: JoinType = `inner`
+    mode: JoinType = `inner`,
   ) {
     super(id, inputA, inputB, output)
     this.#mode = mode
@@ -84,10 +84,10 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   run(): void {
     // Build deltas from input messages
     const deltaA = Index.fromMultiSets<K, V1>(
-      this.inputAMessages() as Array<MultiSet<[K, V1]>>
+      this.inputAMessages() as Array<MultiSet<[K, V1]>>,
     )
     const deltaB = Index.fromMultiSets<K, V2>(
-      this.inputBMessages() as Array<MultiSet<[K, V2]>>
+      this.inputBMessages() as Array<MultiSet<[K, V2]>>,
     )
 
     // Early-out if nothing changed
@@ -130,7 +130,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   private emitInnerResults(
     deltaA: Index<K, V1>,
     deltaB: Index<K, V2>,
-    results: MultiSet<any>
+    results: MultiSet<any>,
   ): void {
     // Emit the three standard delta terms: ΔA⋈B_old, A_old⋈ΔB, ΔA⋈ΔB
     if (deltaA.size > 0) results.extend(deltaA.join(this.#indexB))
@@ -141,7 +141,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   private emitLeftOuterResults(
     deltaA: Index<K, V1>,
     deltaB: Index<K, V2>,
-    results: MultiSet<any>
+    results: MultiSet<any>,
   ): void {
     // Emit unmatched left rows from deltaA
     if (deltaA.size > 0) {
@@ -184,7 +184,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
           if (multiplicity !== 0) {
             results.add(
               [key, [value, null]],
-              transitioningToMatched ? -multiplicity : +multiplicity
+              transitioningToMatched ? -multiplicity : +multiplicity,
             )
           }
         }
@@ -195,7 +195,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   private emitRightOuterResults(
     deltaA: Index<K, V1>,
     deltaB: Index<K, V2>,
-    results: MultiSet<any>
+    results: MultiSet<any>,
   ): void {
     // Emit unmatched right rows from deltaB
     if (deltaB.size > 0) {
@@ -238,7 +238,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
           if (multiplicity !== 0) {
             results.add(
               [key, [null, value]],
-              transitioningToMatched ? -multiplicity : +multiplicity
+              transitioningToMatched ? -multiplicity : +multiplicity,
             )
           }
         }
@@ -259,24 +259,24 @@ export function join<
   T,
 >(
   other: IStreamBuilder<KeyValue<K, V2>>,
-  type: JoinType = `inner`
+  type: JoinType = `inner`,
 ): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<KeyValue<K, [V1 | null, V2 | null]>> => {
     if (stream.graph !== other.graph) {
       throw new Error(`Cannot join streams from different graphs`)
     }
     const output = new StreamBuilder<KeyValue<K, [V1 | null, V2 | null]>>(
       stream.graph,
-      new DifferenceStreamWriter<KeyValue<K, [V1 | null, V2 | null]>>()
+      new DifferenceStreamWriter<KeyValue<K, [V1 | null, V2 | null]>>(),
     )
     const operator = new JoinOperator<K, V1, V2>(
       stream.graph.getNextOperatorId(),
       stream.connectReader() as DifferenceStreamReader<KeyValue<K, V1>>,
       other.connectReader(),
       output.writer,
-      type
+      type,
     )
     stream.graph.addOperator(operator)
     return output
@@ -293,7 +293,7 @@ export function innerJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1, V2]>> {
   return join(other, `inner`) as unknown as PipedOperator<
     T,
@@ -311,7 +311,7 @@ export function antiJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1, null]>> {
   return join(other, `anti`) as unknown as PipedOperator<
     T,
@@ -329,7 +329,7 @@ export function leftJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1, V2 | null]>> {
   return join(other, `left`) as unknown as PipedOperator<
     T,
@@ -347,7 +347,7 @@ export function rightJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1 | null, V2]>> {
   return join(other, `right`) as unknown as PipedOperator<
     T,
@@ -365,7 +365,7 @@ export function fullJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {
   return join(other, `full`) as unknown as PipedOperator<
     T,

package/src/operators/keying.ts

@@ -1,5 +1,5 @@
-import { map } from "./map.js"
-import type { PipedOperator } from "../types.js"
+import { map } from './map.js'
+import type { PipedOperator } from '../types.js'
 
 /**
  * Type for a keyed value
@@ -11,7 +11,7 @@ export type Keyed<K, V> = [K, V]
  * @param keyFn - Function to generate the key for each value
  */
 export function keyBy<T, K>(
-  keyFn: (value: T) => K
+  keyFn: (value: T) => K,
 ): PipedOperator<T, Keyed<K, T>> {
   return map((value: T): Keyed<K, T> => [keyFn(value), value])
 }
@@ -28,7 +28,7 @@ export function unkey<K, V>(): PipedOperator<Keyed<K, V>, V> {
  * @param keyFn - Function to generate the new key for each value
  */
 export function rekey<K1, K2, V>(
-  keyFn: (value: V) => K2
+  keyFn: (value: V) => K2,
 ): PipedOperator<Keyed<K1, V>, Keyed<K2, V>> {
   return map(([_, value]: Keyed<K1, V>): Keyed<K2, V> => [keyFn(value), value])
 }

package/src/operators/map.ts

@@ -1,8 +1,8 @@
-import { DifferenceStreamWriter, LinearUnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that applies a function to each element in the input stream
@@ -14,7 +14,7 @@ export class MapOperator<T, U> extends LinearUnaryOperator<T, U> {
     id: number,
     inputA: DifferenceStreamReader<T>,
     output: DifferenceStreamWriter<U>,
-    f: (data: T) => U
+    f: (data: T) => U,
   ) {
     super(id, inputA, output)
     this.#f = f
@@ -33,13 +33,13 @@ export function map<T, O>(f: (data: T) => O): PipedOperator<T, O> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<O> => {
     const output = new StreamBuilder<O>(
       stream.graph,
-      new DifferenceStreamWriter<O>()
+      new DifferenceStreamWriter<O>(),
     )
     const operator = new MapOperator<T, O>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
-      f
+      f,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/negate.ts

@@ -1,7 +1,7 @@
-import { DifferenceStreamWriter, LinearUnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that negates the multiplicities in the input stream
@@ -19,12 +19,12 @@ export function negate<T>(): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new NegateOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
-      output.writer
+      output.writer,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/orderBy.ts

@@ -1,9 +1,9 @@
-import { topK, topKWithIndex } from "./topK.js"
-import { topKWithFractionalIndex } from "./topKWithFractionalIndex.js"
-import { map } from "./map.js"
-import { innerJoin } from "./join.js"
-import { consolidate } from "./consolidate.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { topK, topKWithIndex } from './topK.js'
+import { topKWithFractionalIndex } from './topKWithFractionalIndex.js'
+import { map } from './map.js'
+import { innerJoin } from './join.js'
+import { consolidate } from './consolidate.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 export interface OrderByOptions<Ve> {
   comparator?: (a: Ve, b: Ve) => number
@@ -14,7 +14,7 @@ export interface OrderByOptions<Ve> {
 type OrderByWithFractionalIndexOptions<Ve> = OrderByOptions<Ve> & {
   setSizeCallback?: (getSize: () => number) => void
   setWindowFn?: (
-    windowFn: (options: { offset?: number; limit?: number }) => void
+    windowFn: (options: { offset?: number; limit?: number }) => void,
   ) => void
 }
 
@@ -28,9 +28,9 @@ type OrderByWithFractionalIndexOptions<Ve> = OrderByOptions<Ve> & {
  */
 export function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByOptions<Ve>
+  options?: OrderByOptions<Ve>,
 ) {
   const limit = options?.limit ?? Infinity
   const offset = options?.offset ?? 0
@@ -54,10 +54,10 @@ export function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(
             [
               key,
               valueExtractor(
-                value as T extends KeyValue<unknown, infer V> ? V : never
+                value as T extends KeyValue<unknown, infer V> ? V : never,
               ),
             ],
-          ] as KeyValue<null, [KeyType, Ve]>
+          ] as KeyValue<null, [KeyType, Ve]>,
       ),
       topK((a, b) => comparator(a[1], b[1]), { limit, offset }),
       map(([_, [key]]) => [key, null] as KeyValue<KeyType, null>),
@@ -65,7 +65,7 @@ export function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(
       map(([key, value]) => {
         return [key, value[1]] as T
       }),
-      consolidate()
+      consolidate(),
     )
   }
 }
@@ -84,9 +84,9 @@ export function orderByWithIndex<
   Ve = unknown,
 >(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByOptions<Ve>
+  options?: OrderByOptions<Ve>,
 ) {
   const limit = options?.limit ?? Infinity
   const offset = options?.offset ?? 0
@@ -100,7 +100,7 @@ export function orderByWithIndex<
     })
 
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<
     KeyValue<
       T extends KeyValue<infer K, unknown> ? K : never,
@@ -118,10 +118,10 @@ export function orderByWithIndex<
             [
               key,
               valueExtractor(
-                value as T extends KeyValue<unknown, infer V> ? V : never
+                value as T extends KeyValue<unknown, infer V> ? V : never,
               ),
             ],
-          ] as KeyValue<null, [KeyType, Ve]>
+          ] as KeyValue<null, [KeyType, Ve]>,
       ),
       topKWithIndex((a, b) => comparator(a[1], b[1]), { limit, offset }),
       map(([_, [[key], index]]) => [key, index] as KeyValue<KeyType, number>),
@@ -129,7 +129,7 @@ export function orderByWithIndex<
       map(([key, [index, value]]) => {
         return [key, [value, index]] as KeyValue<KeyType, [ValueType, number]>
       }),
-      consolidate()
+      consolidate(),
     )
   }
 }
@@ -140,9 +140,9 @@ export function orderByWithFractionalIndexBase<
 >(
   topKFunction: typeof topKWithFractionalIndex,
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByWithFractionalIndexOptions<Ve>
+  options?: OrderByWithFractionalIndexOptions<Ve>,
 ) {
   type KeyType = T extends KeyValue<infer K, unknown> ? K : never
   type ValueType = T extends KeyValue<unknown, infer V> ? V : never
@@ -161,7 +161,7 @@ export function orderByWithFractionalIndexBase<
     })
 
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<[KeyType, [ValueType, string]]> => {
     return stream.pipe(
       topKFunction(
@@ -172,9 +172,9 @@ export function orderByWithFractionalIndexBase<
           offset,
           setSizeCallback,
           setWindowFn,
-        }
+        },
       ),
-      consolidate()
+      consolidate(),
     )
   }
 }
@@ -193,13 +193,13 @@ export function orderByWithFractionalIndex<
   Ve = unknown,
 >(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByWithFractionalIndexOptions<Ve>
+  options?: OrderByWithFractionalIndexOptions<Ve>,
 ) {
   return orderByWithFractionalIndexBase(
     topKWithFractionalIndex,
     valueExtractor,
-    options
+    options,
   )
 }

package/src/operators/orderByBTree.ts

@@ -1,20 +1,20 @@
-import { orderByWithFractionalIndexBase } from "./orderBy.js"
-import { topKWithFractionalIndexBTree } from "./topKWithFractionalIndexBTree.js"
-import type { KeyValue } from "../types.js"
-import type { OrderByOptions } from "./orderBy.js"
+import { orderByWithFractionalIndexBase } from './orderBy.js'
+import { topKWithFractionalIndexBTree } from './topKWithFractionalIndexBTree.js'
+import type { KeyValue } from '../types.js'
+import type { OrderByOptions } from './orderBy.js'
 
 export function orderByWithFractionalIndexBTree<
   T extends KeyValue<unknown, unknown>,
   Ve = unknown,
 >(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByOptions<Ve>
+  options?: OrderByOptions<Ve>,
 ) {
   return orderByWithFractionalIndexBase(
     topKWithFractionalIndexBTree,
     valueExtractor,
-    options
+    options,
   )
 }

package/src/operators/output.ts

@@ -1,8 +1,8 @@
-import { DifferenceStreamWriter, UnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that outputs the messages in the stream
@@ -14,7 +14,7 @@ export class OutputOperator<T> extends UnaryOperator<T> {
     id: number,
     inputA: DifferenceStreamReader<T>,
     outputWriter: DifferenceStreamWriter<T>,
-    fn: (data: MultiSet<T>) => void
+    fn: (data: MultiSet<T>) => void,
   ) {
     super(id, inputA, outputWriter)
     this.#fn = fn
@@ -33,18 +33,18 @@ export class OutputOperator<T> extends UnaryOperator<T> {
  * @param fn - The function to call with each message
  */
 export function output<T>(
-  fn: (data: MultiSet<T>) => void
+  fn: (data: MultiSet<T>) => void,
 ): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const outputStream = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new OutputOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       outputStream.writer,
-      fn
+      fn,
     )
     stream.graph.addOperator(operator)
     return outputStream

package/src/operators/pipe.ts

@@ -1,4 +1,4 @@
-import type { IStreamBuilder, PipedOperator } from "../types.js"
+import type { IStreamBuilder, PipedOperator } from '../types.js'
 
 // Don't judge, this is the only way to type this function.
 // rxjs has very similar code to type its pipe function