@tanstack/db-ivm 0.1.15 → 0.1.16

package/dist/cjs/index.cjs

@@ -22,6 +22,7 @@ const topK = require("./operators/topK.cjs");
 const topKWithFractionalIndex = require("./operators/topKWithFractionalIndex.cjs");
 const groupedTopKWithFractionalIndex = require("./operators/groupedTopKWithFractionalIndex.cjs");
 const orderBy = require("./operators/orderBy.cjs");
+const groupedOrderBy = require("./operators/groupedOrderBy.cjs");
 const filterBy = require("./operators/filterBy.cjs");
 exports.D2 = d2.D2;
 exports.RootStreamBuilder = d2.RootStreamBuilder;
@@ -74,5 +75,6 @@ exports.orderBy = orderBy.orderBy;
 exports.orderByWithFractionalIndex = orderBy.orderByWithFractionalIndex;
 exports.orderByWithFractionalIndexBase = orderBy.orderByWithFractionalIndexBase;
 exports.orderByWithIndex = orderBy.orderByWithIndex;
+exports.groupedOrderByWithFractionalIndex = groupedOrderBy.groupedOrderByWithFractionalIndex;
 exports.filterBy = filterBy.filterBy;
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/operators/groupedOrderBy.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const groupedTopKWithFractionalIndex = require("./groupedTopKWithFractionalIndex.cjs");
+const consolidate = require("./consolidate.cjs");
+function groupedOrderByWithFractionalIndex(valueExtractor, options) {
+  const limit = options.limit ?? Infinity;
+  const offset = options.offset ?? 0;
+  const setSizeCallback = options.setSizeCallback;
+  const setWindowFn = options.setWindowFn;
+  const groupKeyFn = options.groupKeyFn;
+  const comparator = options.comparator ?? ((a, b) => {
+    if (a === b) return 0;
+    if (a < b) return -1;
+    return 1;
+  });
+  return (stream) => {
+    return stream.pipe(
+      groupedTopKWithFractionalIndex.groupedTopKWithFractionalIndex(
+        (a, b) => comparator(valueExtractor(a), valueExtractor(b)),
+        {
+          limit,
+          offset,
+          setSizeCallback,
+          setWindowFn,
+          groupKeyFn
+        }
+      ),
+      consolidate.consolidate()
+    );
+  };
+}
+exports.groupedOrderByWithFractionalIndex = groupedOrderByWithFractionalIndex;
+//# sourceMappingURL=groupedOrderBy.cjs.map

package/dist/cjs/operators/groupedOrderBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"groupedOrderBy.cjs","sources":["../../../src/operators/groupedOrderBy.ts"],"sourcesContent":["import { groupedTopKWithFractionalIndex } from './groupedTopKWithFractionalIndex.js'\nimport { consolidate } from './consolidate.js'\nimport type { IStreamBuilder, KeyValue } from '../types.js'\n\nexport interface GroupedOrderByOptions<Ve> {\n  comparator?: (a: Ve, b: Ve) => number\n  limit?: number\n  offset?: number\n}\n\nexport interface GroupedOrderByWithFractionalIndexOptions<\n  Ve,\n  KeyType = unknown,\n  ValueType = unknown,\n> extends GroupedOrderByOptions<Ve> {\n  setSizeCallback?: (getSize: () => number) => void\n  setWindowFn?: (\n    windowFn: (options: { offset?: number; limit?: number }) => void,\n  ) => void\n  /**\n   * Function to extract a group key from the element's key and value.\n   * Elements with the same group key will be sorted and limited together.\n   */\n  groupKeyFn: (key: KeyType, value: ValueType) => unknown\n}\n\n/**\n * Orders the elements per group and limits the number of results per group, with optional offset and\n * annotates the value with a fractional index.\n * This requires a keyed stream, and uses the `groupedTopKWithFractionalIndex` operator to order elements within each group.\n *\n * Elements are grouped by the provided groupKeyFn, and each group maintains its own sorted collection\n * with independent limit/offset.\n *\n * @param valueExtractor - A function that extracts the value to order by from the element\n * @param options - Configuration including groupKeyFn, comparator, limit, and offset\n * @returns A piped operator that orders the elements per group and limits the number of results per group\n */\nexport function groupedOrderByWithFractionalIndex<\n  T extends KeyValue<unknown, unknown>,\n  Ve = unknown,\n>(\n  valueExtractor: (\n    value: T extends KeyValue<unknown, infer V> ? V : never,\n  ) => Ve,\n  options: GroupedOrderByWithFractionalIndexOptions<\n    Ve,\n    T extends KeyValue<infer K, unknown> ? K : never,\n    T extends KeyValue<unknown, infer V> ? V : never\n  >,\n) {\n  type KeyType = T extends KeyValue<infer K, unknown> ? K : never\n  type ValueType = T extends KeyValue<unknown, infer V> ? V : never\n\n  const limit = options.limit ?? Infinity\n  const offset = options.offset ?? 0\n  const setSizeCallback = options.setSizeCallback\n  const setWindowFn = options.setWindowFn\n  const groupKeyFn = options.groupKeyFn\n  const comparator =\n    options.comparator ??\n    ((a, b) => {\n      // Default to JS like ordering\n      if (a === b) return 0\n      if (a < b) return -1\n      return 1\n    })\n\n  return (\n    stream: IStreamBuilder<T>,\n  ): IStreamBuilder<[KeyType, [ValueType, string]]> => {\n    // Cast to the expected key type for groupedTopKWithFractionalIndex\n    type StreamKey = KeyType extends string | number ? KeyType : string | number\n\n    return stream.pipe(\n      groupedTopKWithFractionalIndex<StreamKey, ValueType>(\n        (a: ValueType, b: ValueType) =>\n          comparator(valueExtractor(a), valueExtractor(b)),\n        {\n          limit,\n          offset,\n          setSizeCallback,\n          setWindowFn,\n          groupKeyFn: groupKeyFn as (\n            key: StreamKey,\n            value: ValueType,\n          ) => unknown,\n        },\n      ) as (\n        stream: IStreamBuilder<T>,\n      ) => IStreamBuilder<[KeyType, [ValueType, string]]>,\n      consolidate(),\n    )\n  }\n}\n"],"names":["groupedTopKWithFractionalIndex","consolidate"],"mappings":";;;;AAsCO,SAAS,kCAId,gBAGA,SAKA;AAIA,QAAM,QAAQ,QAAQ,SAAS;AAC/B,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,kBAAkB,QAAQ;AAChC,QAAM,cAAc,QAAQ;AAC5B,QAAM,aAAa,QAAQ;AAC3B,QAAM,aACJ,QAAQ,eACP,CAAC,GAAG,MAAM;AAET,QAAI,MAAM,EAAG,QAAO;AACpB,QAAI,IAAI,EAAG,QAAO;AAClB,WAAO;AAAA,EACT;AAEF,SAAO,CACL,WACmD;AAInD,WAAO,OAAO;AAAA,MACZA,+BAAAA;AAAAA,QACE,CAAC,GAAc,MACb,WAAW,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC;AAAA,QACjD;AAAA,UACE;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QAAA;AAAA,MAIF;AAAA,MAIFC,YAAAA,YAAA;AAAA,IAAY;AAAA,EAEhB;AACF;;"}

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

@@ -0,0 +1,31 @@
+import { IStreamBuilder, KeyValue } from '../types.js';
+export interface GroupedOrderByOptions<Ve> {
+    comparator?: (a: Ve, b: Ve) => number;
+    limit?: number;
+    offset?: number;
+}
+export interface GroupedOrderByWithFractionalIndexOptions<Ve, KeyType = unknown, ValueType = unknown> extends GroupedOrderByOptions<Ve> {
+    setSizeCallback?: (getSize: () => number) => void;
+    setWindowFn?: (windowFn: (options: {
+        offset?: number;
+        limit?: number;
+    }) => void) => void;
+    /**
+     * Function to extract a group key from the element's key and value.
+     * Elements with the same group key will be sorted and limited together.
+     */
+    groupKeyFn: (key: KeyType, value: ValueType) => unknown;
+}
+/**
+ * Orders the elements per group and limits the number of results per group, with optional offset and
+ * annotates the value with a fractional index.
+ * This requires a keyed stream, and uses the `groupedTopKWithFractionalIndex` operator to order elements within each group.
+ *
+ * Elements are grouped by the provided groupKeyFn, and each group maintains its own sorted collection
+ * with independent limit/offset.
+ *
+ * @param valueExtractor - A function that extracts the value to order by from the element
+ * @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]]>;

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

@@ -16,5 +16,6 @@ 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';

package/dist/esm/index.js

@@ -20,6 +20,7 @@ import { topK, topKWithIndex } from "./operators/topK.js";
 import { TopKWithFractionalIndexOperator, topKWithFractionalIndex } from "./operators/topKWithFractionalIndex.js";
 import { GroupedTopKWithFractionalIndexOperator, groupedTopKWithFractionalIndex } from "./operators/groupedTopKWithFractionalIndex.js";
 import { orderBy, orderByWithFractionalIndex, orderByWithFractionalIndexBase, orderByWithIndex } from "./operators/orderBy.js";
+import { groupedOrderByWithFractionalIndex } from "./operators/groupedOrderBy.js";
 import { filterBy } from "./operators/filterBy.js";
 export {
   ConcatOperator,
@@ -52,6 +53,7 @@ export {
   fullJoin,
   groupBy,
   groupByOperators,
+  groupedOrderByWithFractionalIndex,
   groupedTopKWithFractionalIndex,
   innerJoin,
   join,

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,31 @@
+import { IStreamBuilder, KeyValue } from '../types.js';
+export interface GroupedOrderByOptions<Ve> {
+    comparator?: (a: Ve, b: Ve) => number;
+    limit?: number;
+    offset?: number;
+}
+export interface GroupedOrderByWithFractionalIndexOptions<Ve, KeyType = unknown, ValueType = unknown> extends GroupedOrderByOptions<Ve> {
+    setSizeCallback?: (getSize: () => number) => void;
+    setWindowFn?: (windowFn: (options: {
+        offset?: number;
+        limit?: number;
+    }) => void) => void;
+    /**
+     * Function to extract a group key from the element's key and value.
+     * Elements with the same group key will be sorted and limited together.
+     */
+    groupKeyFn: (key: KeyType, value: ValueType) => unknown;
+}
+/**
+ * Orders the elements per group and limits the number of results per group, with optional offset and
+ * annotates the value with a fractional index.
+ * This requires a keyed stream, and uses the `groupedTopKWithFractionalIndex` operator to order elements within each group.
+ *
+ * Elements are grouped by the provided groupKeyFn, and each group maintains its own sorted collection
+ * with independent limit/offset.
+ *
+ * @param valueExtractor - A function that extracts the value to order by from the element
+ * @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]]>;

package/dist/esm/operators/groupedOrderBy.js

@@ -0,0 +1,33 @@
+import { groupedTopKWithFractionalIndex } from "./groupedTopKWithFractionalIndex.js";
+import { consolidate } from "./consolidate.js";
+function groupedOrderByWithFractionalIndex(valueExtractor, options) {
+  const limit = options.limit ?? Infinity;
+  const offset = options.offset ?? 0;
+  const setSizeCallback = options.setSizeCallback;
+  const setWindowFn = options.setWindowFn;
+  const groupKeyFn = options.groupKeyFn;
+  const comparator = options.comparator ?? ((a, b) => {
+    if (a === b) return 0;
+    if (a < b) return -1;
+    return 1;
+  });
+  return (stream) => {
+    return stream.pipe(
+      groupedTopKWithFractionalIndex(
+        (a, b) => comparator(valueExtractor(a), valueExtractor(b)),
+        {
+          limit,
+          offset,
+          setSizeCallback,
+          setWindowFn,
+          groupKeyFn
+        }
+      ),
+      consolidate()
+    );
+  };
+}
+export {
+  groupedOrderByWithFractionalIndex
+};
+//# sourceMappingURL=groupedOrderBy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"groupedOrderBy.js","sources":["../../../src/operators/groupedOrderBy.ts"],"sourcesContent":["import { groupedTopKWithFractionalIndex } from './groupedTopKWithFractionalIndex.js'\nimport { consolidate } from './consolidate.js'\nimport type { IStreamBuilder, KeyValue } from '../types.js'\n\nexport interface GroupedOrderByOptions<Ve> {\n  comparator?: (a: Ve, b: Ve) => number\n  limit?: number\n  offset?: number\n}\n\nexport interface GroupedOrderByWithFractionalIndexOptions<\n  Ve,\n  KeyType = unknown,\n  ValueType = unknown,\n> extends GroupedOrderByOptions<Ve> {\n  setSizeCallback?: (getSize: () => number) => void\n  setWindowFn?: (\n    windowFn: (options: { offset?: number; limit?: number }) => void,\n  ) => void\n  /**\n   * Function to extract a group key from the element's key and value.\n   * Elements with the same group key will be sorted and limited together.\n   */\n  groupKeyFn: (key: KeyType, value: ValueType) => unknown\n}\n\n/**\n * Orders the elements per group and limits the number of results per group, with optional offset and\n * annotates the value with a fractional index.\n * This requires a keyed stream, and uses the `groupedTopKWithFractionalIndex` operator to order elements within each group.\n *\n * Elements are grouped by the provided groupKeyFn, and each group maintains its own sorted collection\n * with independent limit/offset.\n *\n * @param valueExtractor - A function that extracts the value to order by from the element\n * @param options - Configuration including groupKeyFn, comparator, limit, and offset\n * @returns A piped operator that orders the elements per group and limits the number of results per group\n */\nexport function groupedOrderByWithFractionalIndex<\n  T extends KeyValue<unknown, unknown>,\n  Ve = unknown,\n>(\n  valueExtractor: (\n    value: T extends KeyValue<unknown, infer V> ? V : never,\n  ) => Ve,\n  options: GroupedOrderByWithFractionalIndexOptions<\n    Ve,\n    T extends KeyValue<infer K, unknown> ? K : never,\n    T extends KeyValue<unknown, infer V> ? V : never\n  >,\n) {\n  type KeyType = T extends KeyValue<infer K, unknown> ? K : never\n  type ValueType = T extends KeyValue<unknown, infer V> ? V : never\n\n  const limit = options.limit ?? Infinity\n  const offset = options.offset ?? 0\n  const setSizeCallback = options.setSizeCallback\n  const setWindowFn = options.setWindowFn\n  const groupKeyFn = options.groupKeyFn\n  const comparator =\n    options.comparator ??\n    ((a, b) => {\n      // Default to JS like ordering\n      if (a === b) return 0\n      if (a < b) return -1\n      return 1\n    })\n\n  return (\n    stream: IStreamBuilder<T>,\n  ): IStreamBuilder<[KeyType, [ValueType, string]]> => {\n    // Cast to the expected key type for groupedTopKWithFractionalIndex\n    type StreamKey = KeyType extends string | number ? KeyType : string | number\n\n    return stream.pipe(\n      groupedTopKWithFractionalIndex<StreamKey, ValueType>(\n        (a: ValueType, b: ValueType) =>\n          comparator(valueExtractor(a), valueExtractor(b)),\n        {\n          limit,\n          offset,\n          setSizeCallback,\n          setWindowFn,\n          groupKeyFn: groupKeyFn as (\n            key: StreamKey,\n            value: ValueType,\n          ) => unknown,\n        },\n      ) as (\n        stream: IStreamBuilder<T>,\n      ) => IStreamBuilder<[KeyType, [ValueType, string]]>,\n      consolidate(),\n    )\n  }\n}\n"],"names":[],"mappings":";;AAsCO,SAAS,kCAId,gBAGA,SAKA;AAIA,QAAM,QAAQ,QAAQ,SAAS;AAC/B,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,kBAAkB,QAAQ;AAChC,QAAM,cAAc,QAAQ;AAC5B,QAAM,aAAa,QAAQ;AAC3B,QAAM,aACJ,QAAQ,eACP,CAAC,GAAG,MAAM;AAET,QAAI,MAAM,EAAG,QAAO;AACpB,QAAI,IAAI,EAAG,QAAO;AAClB,WAAO;AAAA,EACT;AAEF,SAAO,CACL,WACmD;AAInD,WAAO,OAAO;AAAA,MACZ;AAAA,QACE,CAAC,GAAc,MACb,WAAW,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC;AAAA,QACjD;AAAA,UACE;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QAAA;AAAA,MAIF;AAAA,MAIF,YAAA;AAAA,IAAY;AAAA,EAEhB;AACF;"}

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

@@ -16,5 +16,6 @@ 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';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/db-ivm",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Incremental View Maintenance for TanStack DB based on Differential Dataflow",
   "author": "Sam Willis",
   "license": "MIT",

package/src/operators/groupedOrderBy.ts

@@ -0,0 +1,95 @@
+import { groupedTopKWithFractionalIndex } from './groupedTopKWithFractionalIndex.js'
+import { consolidate } from './consolidate.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
+
+export interface GroupedOrderByOptions<Ve> {
+  comparator?: (a: Ve, b: Ve) => number
+  limit?: number
+  offset?: number
+}
+
+export interface GroupedOrderByWithFractionalIndexOptions<
+  Ve,
+  KeyType = unknown,
+  ValueType = unknown,
+> extends GroupedOrderByOptions<Ve> {
+  setSizeCallback?: (getSize: () => number) => void
+  setWindowFn?: (
+    windowFn: (options: { offset?: number; limit?: number }) => void,
+  ) => void
+  /**
+   * Function to extract a group key from the element's key and value.
+   * Elements with the same group key will be sorted and limited together.
+   */
+  groupKeyFn: (key: KeyType, value: ValueType) => unknown
+}
+
+/**
+ * Orders the elements per group and limits the number of results per group, with optional offset and
+ * annotates the value with a fractional index.
+ * This requires a keyed stream, and uses the `groupedTopKWithFractionalIndex` operator to order elements within each group.
+ *
+ * Elements are grouped by the provided groupKeyFn, and each group maintains its own sorted collection
+ * with independent limit/offset.
+ *
+ * @param valueExtractor - A function that extracts the value to order by from the element
+ * @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 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
+  >,
+) {
+  type KeyType = T extends KeyValue<infer K, unknown> ? K : never
+  type ValueType = T extends KeyValue<unknown, infer V> ? V : never
+
+  const limit = options.limit ?? Infinity
+  const offset = options.offset ?? 0
+  const setSizeCallback = options.setSizeCallback
+  const setWindowFn = options.setWindowFn
+  const groupKeyFn = options.groupKeyFn
+  const comparator =
+    options.comparator ??
+    ((a, b) => {
+      // Default to JS like ordering
+      if (a === b) return 0
+      if (a < b) return -1
+      return 1
+    })
+
+  return (
+    stream: IStreamBuilder<T>,
+  ): IStreamBuilder<[KeyType, [ValueType, string]]> => {
+    // Cast to the expected key type for groupedTopKWithFractionalIndex
+    type StreamKey = KeyType extends string | number ? KeyType : string | number
+
+    return stream.pipe(
+      groupedTopKWithFractionalIndex<StreamKey, ValueType>(
+        (a: ValueType, b: ValueType) =>
+          comparator(valueExtractor(a), valueExtractor(b)),
+        {
+          limit,
+          offset,
+          setSizeCallback,
+          setWindowFn,
+          groupKeyFn: groupKeyFn as (
+            key: StreamKey,
+            value: ValueType,
+          ) => unknown,
+        },
+      ) as (
+        stream: IStreamBuilder<T>,
+      ) => IStreamBuilder<[KeyType, [ValueType, string]]>,
+      consolidate(),
+    )
+  }
+}

package/src/operators/index.ts

@@ -16,5 +16,6 @@ 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'