@electric-sql/d2ts/dist/sqlite/operators/groupBy.d.ts

D2TS is a TypeScript implementation of Differential Dataflow.

import { IStreamBuilder, KeyValue } from '../../types.js';
import { SQLiteDb } from '../database.js';
export { sum, count, avg, min, max, median } from '../../operators/groupBy.js';
type GroupKey = Record<string, unknown>;
type BasicAggregateFunction<T, R, V = unknown> = {
    preMap: (data: T) => V;
    reduce: (values: [V, number][]) => V;
    postMap?: (result: V) => R;
};
type PipedAggregateFunction<T, R> = {
    pipe: (stream: IStreamBuilder<T>) => IStreamBuilder<KeyValue<string, R>>;
};
type AggregateFunction<T, R, V = unknown> = BasicAggregateFunction<T, R, V> | PipedAggregateFunction<T, R>;
type ExtractAggregateReturnType<T, A> = A extends AggregateFunction<T, infer R, any> ? R : never;
type AggregatesReturnType<T, A> = {
    [K in keyof A]: ExtractAggregateReturnType<T, A[K]>;
};
/**
 * Creates a mode aggregate function that computes the most frequent value in a group
 * SQLite-compatible version that uses a serializable object instead of Map
 * @param valueExtractor Function to extract a value from each data entry
 */
export declare function mode<T>(valueExtractor?: (value: T) => number): AggregateFunction<T, number, Record<string, number>>;
/**
 * Groups data by key and applies multiple aggregate operations
 * SQLite version that persists state to a database
 *
 * @param keyExtractor Function to extract grouping key from data
 * @param aggregates Object mapping aggregate names to aggregate functions
 * @param db Optional SQLite database (can be injected via context)
 */
export declare function groupBy<T, K extends GroupKey, A extends Record<string, AggregateFunction<T, any, any>>>(keyExtractor: (data: T) => K, aggregates: A, db?: SQLiteDb): (stream: IStreamBuilder<T>) => IStreamBuilder<KeyValue<string, K & AggregatesReturnType<T, A>>>;