@tanstack/table-core 9.0.0-beta.47 → 9.0.0-beta.49

package/src/types/TableFeatures.ts

@@ -10,7 +10,7 @@ import type { StockFeatures } from '../features/stockFeatures'
 import type { RowModel } from '../core/row-models/coreRowModelsFeature.types'
 import type { FilterFn } from '../features/column-filtering/columnFilteringFeature.types'
 import type { SortFn } from '../features/row-sorting/rowSortingFeature.types'
-import type { AggregationFn } from '../features/column-grouping/columnGroupingFeature.types'
+import type { AggregationFnDef } from '../features/aggregation/aggregationFeature.types'
 
 /**
  * Detects whether a type is `any`.
@@ -90,9 +90,9 @@ export type NonFeatureKeys =
  */
 export interface FeatureSlotPrereqs {
   /**
-   * Named aggregation functions are only meaningful when grouping is enabled.
+   * Named aggregation functions require the independent aggregation feature.
    */
-  aggregationFns: 'columnGroupingFeature'
+  aggregationFns: 'aggregationFeature'
   /**
    * Column resizing builds on the column sizing state and APIs.
    */
@@ -190,7 +190,7 @@ export interface TableFeatures
    * Spreading the exported `aggregationFns` registry also works, but puts
    * every built-in aggregation function in your bundle.
    */
-  aggregationFns?: Record<string, AggregationFn<any, any>>
+  aggregationFns?: Record<string, AggregationFnDef<any, any, any, any>>
   /**
    * Type-only slot for declaring the type of `columnDef.meta` for all columns
    * of this table.

package/src/types/TableOptions.ts

@@ -4,6 +4,7 @@ import type { TableOptions_Columns } from '../core/columns/coreColumnsFeature.ty
 import type { TableOptions_Rows } from '../core/rows/coreRowsFeature.types'
 import type { TableOptions_Table } from '../core/table/coreTablesFeature.types'
 import type { TableOptions_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
+import type { TableOptions_Aggregation } from '../features/aggregation/aggregationFeature.types'
 import type { TableOptions_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
 import type { TableOptions_ColumnOrdering } from '../features/column-ordering/columnOrderingFeature.types'
 import type { TableOptions_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types'
@@ -58,6 +59,7 @@ export interface TableOptions_FeatureMap<
   in out TFeatures extends TableFeatures,
   in out TData extends RowData,
 > {
+  aggregationFeature: TableOptions_Aggregation
   columnFilteringFeature: TableOptions_ColumnFiltering<TFeatures, TData>
   columnGroupingFeature: TableOptions_ColumnGrouping
   columnOrderingFeature: TableOptions_ColumnOrdering
@@ -74,6 +76,7 @@ export interface TableOptions_FeatureMap<
 }
 
 type TableOptions_StockFeatureKeys =
+  | 'aggregationFeature'
   | 'columnFilteringFeature'
   | 'columnGroupingFeature'
   | 'columnOrderingFeature'
@@ -133,7 +136,8 @@ export type TableOptions_All<
   TData extends RowData,
 > = TableOptions_Core<TFeatures, TData> &
   Partial<
-    TableOptions_ColumnFiltering<TFeatures, TData> &
+    TableOptions_Aggregation &
+      TableOptions_ColumnFiltering<TFeatures, TData> &
       TableOptions_ColumnGrouping &
       TableOptions_ColumnOrdering &
       TableOptions_ColumnPinning &

package/src/worker/initTableWorker.ts

@@ -84,7 +84,7 @@ export function initTableWorker<
         // per group. Sync tables aggregate lazily (visible cells only), so
         // auto-aggregating every column would explode on high-cardinality
         // grouping for values nothing renders. Read the RAW column defs:
-        // columnGroupingFeature injects default aggregatedCell/aggregationFn
+        // aggregationFeature injects default aggregatedCell/aggregationFn
         // into every resolved columnDef, so the resolved defs can't tell
         // explicit from default.
         aggregateColumnIds = flattenColumnDefs(config.columns as Array<any>)

package/dist/fns/aggregationFns.cjs

@@ -1,234 +0,0 @@
-
-//#region src/fns/aggregationFns.ts
-/**
-* Builds an `AggregationFn` from a value-level reducer plus optional
-* `resolveDataValue` and `fromRows` settings.
-*
-* The `aggregate` reducer receives an array of the group rows' values, each
-* already passed through `resolveDataValue` when one is defined. Keeping
-* normalization in the resolver means a variant of an existing aggregation
-* function only has to swap the resolver, not re-implement the computation.
-*
-* The definition is attached to the returned function, so a variant can be
-* created by spreading a built-in aggregation function and overriding what
-* differs. For example, a `min` that works on date columns:
-*
-* ```ts
-* const earliest = constructAggregationFn({
-*   ...aggregationFn_min,
-*   resolveDataValue: (value) =>
-*     value instanceof Date ? value.getTime() : value,
-* })
-* ```
-*
-* The built-in `count`, `first`, and `last` aggregation functions are plain
-* row-level functions instead: they read group position or size and never
-* look at every value, so materializing a values array would be wasted work.
-*/
-function constructAggregationFn(def) {
-	const aggregationFn = Object.assign((columnId, leafRows, childRows) => {
-		const rows = aggregationFn.fromRows === "childRows" ? childRows : leafRows;
-		const resolveDataValue = aggregationFn.resolveDataValue;
-		const values = new Array(rows.length);
-		for (let i = 0; i < rows.length; i++) {
-			const value = rows[i].getValue(columnId);
-			values[i] = resolveDataValue ? resolveDataValue(value) : value;
-		}
-		return aggregationFn.aggregate(values, rows, columnId);
-	}, def);
-	return aggregationFn;
-}
-/**
-* Sums numeric child-row values for a grouped column.
-*
-* Non-number values contribute `0`. Child rows are used so nested group totals
-* can reuse already aggregated values.
-*/
-const aggregationFn_sum = constructAggregationFn({
-	fromRows: "childRows",
-	aggregate: (values) => {
-		let sumValue = 0;
-		for (let i = 0; i < values.length; i++) {
-			const nextValue = values[i];
-			sumValue += typeof nextValue === "number" ? nextValue : 0;
-		}
-		return sumValue;
-	}
-});
-/**
-* Finds the minimum numeric child-row value for a grouped column.
-*
-* Nullish and non-number values are ignored. Returns `undefined` when no
-* numeric value is found.
-*/
-const aggregationFn_min = constructAggregationFn({
-	fromRows: "childRows",
-	aggregate: (values) => {
-		let minValue;
-		for (let i = 0; i < values.length; i++) {
-			const value = values[i];
-			if (typeof value === "number" && (minValue === void 0 || value < minValue)) minValue = value;
-		}
-		return minValue;
-	}
-});
-/**
-* Finds the maximum numeric child-row value for a grouped column.
-*
-* Nullish and non-number values are ignored. Returns `undefined` when no
-* numeric value is found.
-*/
-const aggregationFn_max = constructAggregationFn({
-	fromRows: "childRows",
-	aggregate: (values) => {
-		let maxValue;
-		for (let i = 0; i < values.length; i++) {
-			const value = values[i];
-			if (typeof value === "number" && (maxValue === void 0 || value > maxValue)) maxValue = value;
-		}
-		return maxValue;
-	}
-});
-/**
-* Finds the numeric extent for a grouped column.
-*
-* Returns `[min, max]`, where each entry is `undefined` when no numeric value is
-* present.
-*/
-const aggregationFn_extent = constructAggregationFn({
-	fromRows: "childRows",
-	aggregate: (values) => {
-		let minValue;
-		let maxValue;
-		for (let i = 0; i < values.length; i++) {
-			const value = values[i];
-			if (typeof value === "number") if (minValue === void 0) minValue = maxValue = value;
-			else {
-				if (minValue > value) minValue = value;
-				if (maxValue < value) maxValue = value;
-			}
-		}
-		return [minValue, maxValue];
-	}
-});
-/**
-* Averages numeric leaf-row values for a grouped column.
-*
-* Number-like values are coerced with unary `+`; nullish and non-numeric values
-* are ignored.
-*/
-const aggregationFn_mean = constructAggregationFn({ aggregate: (values) => {
-	let count = 0;
-	let sumValue = 0;
-	for (let i = 0; i < values.length; i++) {
-		const value = values[i];
-		if (value != null && typeof value === "number") {
-			++count;
-			sumValue += value;
-		} else if (value != null) {
-			const numValue = +value;
-			if (!Number.isNaN(numValue)) {
-				++count;
-				sumValue += numValue;
-			}
-		}
-	}
-	if (count) return sumValue / count;
-} });
-/**
-* Computes the median of numeric leaf-row values for a grouped column.
-*
-* All values must be numbers. If any value is non-numeric, or no leaf rows are
-* present, the result is `undefined`.
-*/
-const aggregationFn_median = constructAggregationFn({ aggregate: (values) => {
-	if (!values.length) return;
-	for (let i = 0; i < values.length; i++) if (typeof values[i] !== "number") return;
-	if (values.length === 1) return values[0];
-	const mid = Math.floor(values.length / 2);
-	values.sort((a, b) => a - b);
-	return values.length % 2 !== 0 ? values[mid] : (values[mid - 1] + values[mid]) / 2;
-} });
-/**
-* Collects unique leaf-row values for a grouped column.
-*
-* Values are compared with JavaScript `Set` semantics.
-*/
-const aggregationFn_unique = constructAggregationFn({ aggregate: (values) => Array.from(new Set(values).values()) });
-/**
-* Counts unique leaf-row values for a grouped column.
-*
-* Values are compared with JavaScript `Set` semantics.
-*/
-const aggregationFn_uniqueCount = constructAggregationFn({ aggregate: (values) => new Set(values).size });
-/**
-* Counts the number of leaf rows in the group.
-*
-* The column id is ignored because the result is based only on group size.
-* This is a plain row-level function (not built with
-* `constructAggregationFn`) because it never reads row values.
-*/
-function aggregationFn_count(_columnId, leafRows) {
-	return leafRows.length;
-}
-/**
-* Returns the first leaf-row value for a grouped column.
-*
-* This is a plain row-level function (not built with
-* `constructAggregationFn`) because it only reads one positional value.
-*/
-function aggregationFn_first(columnId, leafRows) {
-	return leafRows[0]?.getValue(columnId);
-}
-/**
-* Returns the last leaf-row value for a grouped column.
-*
-* This is a plain row-level function (not built with
-* `constructAggregationFn`) because it only reads one positional value.
-*/
-function aggregationFn_last(columnId, leafRows) {
-	return leafRows[leafRows.length - 1]?.getValue(columnId);
-}
-/**
-* The built-in aggregation function registry.
-*
-* Registering this full object opts out of tree-shaking: every built-in
-* aggregation function ends up in your bundle. Prefer importing the
-* `aggregationFn_*` functions you actually use and registering just those in
-* the `aggregationFns` slot, or passing them directly to the `aggregationFn`
-* column option.
-*
-* @deprecated Import individual `aggregationFn_*` functions instead for a
-* smaller bundle. This export still works and is not going away in v9, but
-* built-in name resolution (including `aggregationFn: 'auto'`) only finds
-* functions you register yourself.
-*/
-const aggregationFns = {
-	sum: aggregationFn_sum,
-	min: aggregationFn_min,
-	max: aggregationFn_max,
-	extent: aggregationFn_extent,
-	mean: aggregationFn_mean,
-	median: aggregationFn_median,
-	unique: aggregationFn_unique,
-	uniqueCount: aggregationFn_uniqueCount,
-	count: aggregationFn_count,
-	first: aggregationFn_first,
-	last: aggregationFn_last
-};
-
-//#endregion
-exports.aggregationFn_count = aggregationFn_count;
-exports.aggregationFn_extent = aggregationFn_extent;
-exports.aggregationFn_first = aggregationFn_first;
-exports.aggregationFn_last = aggregationFn_last;
-exports.aggregationFn_max = aggregationFn_max;
-exports.aggregationFn_mean = aggregationFn_mean;
-exports.aggregationFn_median = aggregationFn_median;
-exports.aggregationFn_min = aggregationFn_min;
-exports.aggregationFn_sum = aggregationFn_sum;
-exports.aggregationFn_unique = aggregationFn_unique;
-exports.aggregationFn_uniqueCount = aggregationFn_uniqueCount;
-exports.aggregationFns = aggregationFns;
-exports.constructAggregationFn = constructAggregationFn;
-//# sourceMappingURL=aggregationFns.cjs.map

package/dist/fns/aggregationFns.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"aggregationFns.cjs","names":[],"sources":["../../src/fns/aggregationFns.ts"],"sourcesContent":["import type {\n  AggregationFnDef,\n  CreatedAggregationFn,\n} from '../features/column-grouping/columnGroupingFeature.types'\nimport type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { Row } from '../types/Row'\n\n/**\n * Builds an `AggregationFn` from a value-level reducer plus optional\n * `resolveDataValue` and `fromRows` settings.\n *\n * The `aggregate` reducer receives an array of the group rows' values, each\n * already passed through `resolveDataValue` when one is defined. Keeping\n * normalization in the resolver means a variant of an existing aggregation\n * function only has to swap the resolver, not re-implement the computation.\n *\n * The definition is attached to the returned function, so a variant can be\n * created by spreading a built-in aggregation function and overriding what\n * differs. For example, a `min` that works on date columns:\n *\n * ```ts\n * const earliest = constructAggregationFn({\n *   ...aggregationFn_min,\n *   resolveDataValue: (value) =>\n *     value instanceof Date ? value.getTime() : value,\n * })\n * ```\n *\n * The built-in `count`, `first`, and `last` aggregation functions are plain\n * row-level functions instead: they read group position or size and never\n * look at every value, so materializing a values array would be wasted work.\n */\nexport function constructAggregationFn<\n  TFeatures extends TableFeatures = any,\n  TData extends RowData = any,\n>(\n  def: AggregationFnDef<TFeatures, TData>,\n): CreatedAggregationFn<TFeatures, TData> {\n  const aggregationFn: CreatedAggregationFn<TFeatures, TData> = Object.assign(\n    <TRowFeatures extends TableFeatures, TRowData extends RowData>(\n      columnId: string,\n      leafRows: Array<Row<TRowFeatures, TRowData>>,\n      childRows: Array<Row<TRowFeatures, TRowData>>,\n    ): any => {\n      const rows = aggregationFn.fromRows === 'childRows' ? childRows : leafRows\n      const resolveDataValue = aggregationFn.resolveDataValue\n      const values: Array<any> = new Array(rows.length)\n      for (let i = 0; i < rows.length; i++) {\n        const value = rows[i]!.getValue(columnId)\n        values[i] = resolveDataValue ? resolveDataValue(value) : value\n      }\n      // The def's reducer is typed against the factory's TFeatures/TData;\n      // the caller's row generics are erased at this boundary.\n      return aggregationFn.aggregate(values, rows as any, columnId)\n    },\n    def,\n  )\n  return aggregationFn\n}\n\n/**\n * Sums numeric child-row values for a grouped column.\n *\n * Non-number values contribute `0`. Child rows are used so nested group totals\n * can reuse already aggregated values.\n */\nexport const aggregationFn_sum = constructAggregationFn({\n  fromRows: 'childRows',\n  aggregate: (values) => {\n    let sumValue = 0\n    for (let i = 0; i < values.length; i++) {\n      const nextValue = values[i]\n      sumValue += typeof nextValue === 'number' ? nextValue : 0\n    }\n    return sumValue\n  },\n})\n\n/**\n * Finds the minimum numeric child-row value for a grouped column.\n *\n * Nullish and non-number values are ignored. Returns `undefined` when no\n * numeric value is found.\n */\nexport const aggregationFn_min = constructAggregationFn({\n  fromRows: 'childRows',\n  aggregate: (values) => {\n    let minValue: number | undefined\n\n    for (let i = 0; i < values.length; i++) {\n      const value = values[i]\n      if (\n        typeof value === 'number' &&\n        (minValue === undefined || value < minValue)\n      ) {\n        minValue = value\n      }\n    }\n\n    return minValue\n  },\n})\n\n/**\n * Finds the maximum numeric child-row value for a grouped column.\n *\n * Nullish and non-number values are ignored. Returns `undefined` when no\n * numeric value is found.\n */\nexport const aggregationFn_max = constructAggregationFn({\n  fromRows: 'childRows',\n  aggregate: (values) => {\n    let maxValue: number | undefined\n\n    for (let i = 0; i < values.length; i++) {\n      const value = values[i]\n      if (\n        typeof value === 'number' &&\n        (maxValue === undefined || value > maxValue)\n      ) {\n        maxValue = value\n      }\n    }\n\n    return maxValue\n  },\n})\n\n/**\n * Finds the numeric extent for a grouped column.\n *\n * Returns `[min, max]`, where each entry is `undefined` when no numeric value is\n * present.\n */\nexport const aggregationFn_extent = constructAggregationFn({\n  fromRows: 'childRows',\n  aggregate: (values) => {\n    let minValue: number | undefined\n    let maxValue: number | undefined\n\n    for (let i = 0; i < values.length; i++) {\n      const value = values[i]\n      if (typeof value === 'number') {\n        if (minValue === undefined) {\n          minValue = maxValue = value\n        } else {\n          if (minValue > value) minValue = value\n          if (maxValue! < value) maxValue = value\n        }\n      }\n    }\n\n    return [minValue, maxValue]\n  },\n})\n\n/**\n * Averages numeric leaf-row values for a grouped column.\n *\n * Number-like values are coerced with unary `+`; nullish and non-numeric values\n * are ignored.\n */\nexport const aggregationFn_mean = constructAggregationFn({\n  aggregate: (values) => {\n    let count = 0\n    let sumValue = 0\n\n    for (let i = 0; i < values.length; i++) {\n      const value = values[i]\n      if (value != null && typeof value === 'number') {\n        ++count\n        sumValue += value\n      } else if (value != null) {\n        const numValue = +value\n        if (!Number.isNaN(numValue)) {\n          ++count\n          sumValue += numValue\n        }\n      }\n    }\n\n    if (count) return sumValue / count\n\n    return\n  },\n})\n\n/**\n * Computes the median of numeric leaf-row values for a grouped column.\n *\n * All values must be numbers. If any value is non-numeric, or no leaf rows are\n * present, the result is `undefined`.\n */\nexport const aggregationFn_median = constructAggregationFn({\n  aggregate: (values: Array<number>) => {\n    if (!values.length) {\n      return\n    }\n\n    for (let i = 0; i < values.length; i++) {\n      if (typeof values[i] !== 'number') return\n    }\n\n    if (values.length === 1) {\n      return values[0]\n    }\n\n    const mid = Math.floor(values.length / 2)\n    values.sort((a, b) => a - b)\n    return values.length % 2 !== 0\n      ? values[mid]\n      : (values[mid - 1]! + values[mid]!) / 2\n  },\n})\n\n/**\n * Collects unique leaf-row values for a grouped column.\n *\n * Values are compared with JavaScript `Set` semantics.\n */\nexport const aggregationFn_unique = constructAggregationFn({\n  aggregate: (values) => Array.from(new Set(values).values()),\n})\n\n/**\n * Counts unique leaf-row values for a grouped column.\n *\n * Values are compared with JavaScript `Set` semantics.\n */\nexport const aggregationFn_uniqueCount = constructAggregationFn({\n  aggregate: (values) => new Set(values).size,\n})\n\n/**\n * Counts the number of leaf rows in the group.\n *\n * The column id is ignored because the result is based only on group size.\n * This is a plain row-level function (not built with\n * `constructAggregationFn`) because it never reads row values.\n */\nexport function aggregationFn_count<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(_columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  return leafRows.length\n}\n\n/**\n * Returns the first leaf-row value for a grouped column.\n *\n * This is a plain row-level function (not built with\n * `constructAggregationFn`) because it only reads one positional value.\n */\nexport function aggregationFn_first<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  return leafRows[0]?.getValue(columnId)\n}\n\n/**\n * Returns the last leaf-row value for a grouped column.\n *\n * This is a plain row-level function (not built with\n * `constructAggregationFn`) because it only reads one positional value.\n */\nexport function aggregationFn_last<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  return leafRows[leafRows.length - 1]?.getValue(columnId)\n}\n\n/**\n * The built-in aggregation function registry.\n *\n * Registering this full object opts out of tree-shaking: every built-in\n * aggregation function ends up in your bundle. Prefer importing the\n * `aggregationFn_*` functions you actually use and registering just those in\n * the `aggregationFns` slot, or passing them directly to the `aggregationFn`\n * column option.\n *\n * @deprecated Import individual `aggregationFn_*` functions instead for a\n * smaller bundle. This export still works and is not going away in v9, but\n * built-in name resolution (including `aggregationFn: 'auto'`) only finds\n * functions you register yourself.\n */\nexport const aggregationFns = {\n  sum: aggregationFn_sum,\n  min: aggregationFn_min,\n  max: aggregationFn_max,\n  extent: aggregationFn_extent,\n  mean: aggregationFn_mean,\n  median: aggregationFn_median,\n  unique: aggregationFn_unique,\n  uniqueCount: aggregationFn_uniqueCount,\n  count: aggregationFn_count,\n  first: aggregationFn_first,\n  last: aggregationFn_last,\n}\n\nexport type BuiltInAggregationFn = keyof typeof aggregationFns\n"],"mappings":"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"}

package/dist/fns/aggregationFns.d.cts

@@ -1,139 +0,0 @@
-import { RowData } from "../types/type-utils.cjs";
-import { AggregationFnDef, CreatedAggregationFn } from "../features/column-grouping/columnGroupingFeature.types.cjs";
-import { Row } from "../types/Row.cjs";
-import { TableFeatures } from "../types/TableFeatures.cjs";
-
-//#region src/fns/aggregationFns.d.ts
-/**
- * Builds an `AggregationFn` from a value-level reducer plus optional
- * `resolveDataValue` and `fromRows` settings.
- *
- * The `aggregate` reducer receives an array of the group rows' values, each
- * already passed through `resolveDataValue` when one is defined. Keeping
- * normalization in the resolver means a variant of an existing aggregation
- * function only has to swap the resolver, not re-implement the computation.
- *
- * The definition is attached to the returned function, so a variant can be
- * created by spreading a built-in aggregation function and overriding what
- * differs. For example, a `min` that works on date columns:
- *
- * ```ts
- * const earliest = constructAggregationFn({
- *   ...aggregationFn_min,
- *   resolveDataValue: (value) =>
- *     value instanceof Date ? value.getTime() : value,
- * })
- * ```
- *
- * The built-in `count`, `first`, and `last` aggregation functions are plain
- * row-level functions instead: they read group position or size and never
- * look at every value, so materializing a values array would be wasted work.
- */
-declare function constructAggregationFn<TFeatures extends TableFeatures = any, TData extends RowData = any>(def: AggregationFnDef<TFeatures, TData>): CreatedAggregationFn<TFeatures, TData>;
-/**
- * Sums numeric child-row values for a grouped column.
- *
- * Non-number values contribute `0`. Child rows are used so nested group totals
- * can reuse already aggregated values.
- */
-declare const aggregationFn_sum: CreatedAggregationFn<any, any>;
-/**
- * Finds the minimum numeric child-row value for a grouped column.
- *
- * Nullish and non-number values are ignored. Returns `undefined` when no
- * numeric value is found.
- */
-declare const aggregationFn_min: CreatedAggregationFn<any, any>;
-/**
- * Finds the maximum numeric child-row value for a grouped column.
- *
- * Nullish and non-number values are ignored. Returns `undefined` when no
- * numeric value is found.
- */
-declare const aggregationFn_max: CreatedAggregationFn<any, any>;
-/**
- * Finds the numeric extent for a grouped column.
- *
- * Returns `[min, max]`, where each entry is `undefined` when no numeric value is
- * present.
- */
-declare const aggregationFn_extent: CreatedAggregationFn<any, any>;
-/**
- * Averages numeric leaf-row values for a grouped column.
- *
- * Number-like values are coerced with unary `+`; nullish and non-numeric values
- * are ignored.
- */
-declare const aggregationFn_mean: CreatedAggregationFn<any, any>;
-/**
- * Computes the median of numeric leaf-row values for a grouped column.
- *
- * All values must be numbers. If any value is non-numeric, or no leaf rows are
- * present, the result is `undefined`.
- */
-declare const aggregationFn_median: CreatedAggregationFn<any, any>;
-/**
- * Collects unique leaf-row values for a grouped column.
- *
- * Values are compared with JavaScript `Set` semantics.
- */
-declare const aggregationFn_unique: CreatedAggregationFn<any, any>;
-/**
- * Counts unique leaf-row values for a grouped column.
- *
- * Values are compared with JavaScript `Set` semantics.
- */
-declare const aggregationFn_uniqueCount: CreatedAggregationFn<any, any>;
-/**
- * Counts the number of leaf rows in the group.
- *
- * The column id is ignored because the result is based only on group size.
- * This is a plain row-level function (not built with
- * `constructAggregationFn`) because it never reads row values.
- */
-declare function aggregationFn_count<TFeatures extends TableFeatures, TData extends RowData>(_columnId: string, leafRows: Array<Row<TFeatures, TData>>): number;
-/**
- * Returns the first leaf-row value for a grouped column.
- *
- * This is a plain row-level function (not built with
- * `constructAggregationFn`) because it only reads one positional value.
- */
-declare function aggregationFn_first<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): unknown;
-/**
- * Returns the last leaf-row value for a grouped column.
- *
- * This is a plain row-level function (not built with
- * `constructAggregationFn`) because it only reads one positional value.
- */
-declare function aggregationFn_last<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): unknown;
-/**
- * The built-in aggregation function registry.
- *
- * Registering this full object opts out of tree-shaking: every built-in
- * aggregation function ends up in your bundle. Prefer importing the
- * `aggregationFn_*` functions you actually use and registering just those in
- * the `aggregationFns` slot, or passing them directly to the `aggregationFn`
- * column option.
- *
- * @deprecated Import individual `aggregationFn_*` functions instead for a
- * smaller bundle. This export still works and is not going away in v9, but
- * built-in name resolution (including `aggregationFn: 'auto'`) only finds
- * functions you register yourself.
- */
-declare const aggregationFns: {
-  sum: CreatedAggregationFn<any, any>;
-  min: CreatedAggregationFn<any, any>;
-  max: CreatedAggregationFn<any, any>;
-  extent: CreatedAggregationFn<any, any>;
-  mean: CreatedAggregationFn<any, any>;
-  median: CreatedAggregationFn<any, any>;
-  unique: CreatedAggregationFn<any, any>;
-  uniqueCount: CreatedAggregationFn<any, any>;
-  count: typeof aggregationFn_count;
-  first: typeof aggregationFn_first;
-  last: typeof aggregationFn_last;
-};
-type BuiltInAggregationFn = keyof typeof aggregationFns;
-//#endregion
-export { BuiltInAggregationFn, aggregationFn_count, aggregationFn_extent, aggregationFn_first, aggregationFn_last, aggregationFn_max, aggregationFn_mean, aggregationFn_median, aggregationFn_min, aggregationFn_sum, aggregationFn_unique, aggregationFn_uniqueCount, aggregationFns, constructAggregationFn };
-//# sourceMappingURL=aggregationFns.d.cts.map

package/dist/fns/aggregationFns.d.ts

@@ -1,139 +0,0 @@
-import { RowData } from "../types/type-utils.js";
-import { AggregationFnDef, CreatedAggregationFn } from "../features/column-grouping/columnGroupingFeature.types.js";
-import { Row } from "../types/Row.js";
-import { TableFeatures } from "../types/TableFeatures.js";
-
-//#region src/fns/aggregationFns.d.ts
-/**
- * Builds an `AggregationFn` from a value-level reducer plus optional
- * `resolveDataValue` and `fromRows` settings.
- *
- * The `aggregate` reducer receives an array of the group rows' values, each
- * already passed through `resolveDataValue` when one is defined. Keeping
- * normalization in the resolver means a variant of an existing aggregation
- * function only has to swap the resolver, not re-implement the computation.
- *
- * The definition is attached to the returned function, so a variant can be
- * created by spreading a built-in aggregation function and overriding what
- * differs. For example, a `min` that works on date columns:
- *
- * ```ts
- * const earliest = constructAggregationFn({
- *   ...aggregationFn_min,
- *   resolveDataValue: (value) =>
- *     value instanceof Date ? value.getTime() : value,
- * })
- * ```
- *
- * The built-in `count`, `first`, and `last` aggregation functions are plain
- * row-level functions instead: they read group position or size and never
- * look at every value, so materializing a values array would be wasted work.
- */
-declare function constructAggregationFn<TFeatures extends TableFeatures = any, TData extends RowData = any>(def: AggregationFnDef<TFeatures, TData>): CreatedAggregationFn<TFeatures, TData>;
-/**
- * Sums numeric child-row values for a grouped column.
- *
- * Non-number values contribute `0`. Child rows are used so nested group totals
- * can reuse already aggregated values.
- */
-declare const aggregationFn_sum: CreatedAggregationFn<any, any>;
-/**
- * Finds the minimum numeric child-row value for a grouped column.
- *
- * Nullish and non-number values are ignored. Returns `undefined` when no
- * numeric value is found.
- */
-declare const aggregationFn_min: CreatedAggregationFn<any, any>;
-/**
- * Finds the maximum numeric child-row value for a grouped column.
- *
- * Nullish and non-number values are ignored. Returns `undefined` when no
- * numeric value is found.
- */
-declare const aggregationFn_max: CreatedAggregationFn<any, any>;
-/**
- * Finds the numeric extent for a grouped column.
- *
- * Returns `[min, max]`, where each entry is `undefined` when no numeric value is
- * present.
- */
-declare const aggregationFn_extent: CreatedAggregationFn<any, any>;
-/**
- * Averages numeric leaf-row values for a grouped column.
- *
- * Number-like values are coerced with unary `+`; nullish and non-numeric values
- * are ignored.
- */
-declare const aggregationFn_mean: CreatedAggregationFn<any, any>;
-/**
- * Computes the median of numeric leaf-row values for a grouped column.
- *
- * All values must be numbers. If any value is non-numeric, or no leaf rows are
- * present, the result is `undefined`.
- */
-declare const aggregationFn_median: CreatedAggregationFn<any, any>;
-/**
- * Collects unique leaf-row values for a grouped column.
- *
- * Values are compared with JavaScript `Set` semantics.
- */
-declare const aggregationFn_unique: CreatedAggregationFn<any, any>;
-/**
- * Counts unique leaf-row values for a grouped column.
- *
- * Values are compared with JavaScript `Set` semantics.
- */
-declare const aggregationFn_uniqueCount: CreatedAggregationFn<any, any>;
-/**
- * Counts the number of leaf rows in the group.
- *
- * The column id is ignored because the result is based only on group size.
- * This is a plain row-level function (not built with
- * `constructAggregationFn`) because it never reads row values.
- */
-declare function aggregationFn_count<TFeatures extends TableFeatures, TData extends RowData>(_columnId: string, leafRows: Array<Row<TFeatures, TData>>): number;
-/**
- * Returns the first leaf-row value for a grouped column.
- *
- * This is a plain row-level function (not built with
- * `constructAggregationFn`) because it only reads one positional value.
- */
-declare function aggregationFn_first<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): unknown;
-/**
- * Returns the last leaf-row value for a grouped column.
- *
- * This is a plain row-level function (not built with
- * `constructAggregationFn`) because it only reads one positional value.
- */
-declare function aggregationFn_last<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): unknown;
-/**
- * The built-in aggregation function registry.
- *
- * Registering this full object opts out of tree-shaking: every built-in
- * aggregation function ends up in your bundle. Prefer importing the
- * `aggregationFn_*` functions you actually use and registering just those in
- * the `aggregationFns` slot, or passing them directly to the `aggregationFn`
- * column option.
- *
- * @deprecated Import individual `aggregationFn_*` functions instead for a
- * smaller bundle. This export still works and is not going away in v9, but
- * built-in name resolution (including `aggregationFn: 'auto'`) only finds
- * functions you register yourself.
- */
-declare const aggregationFns: {
-  sum: CreatedAggregationFn<any, any>;
-  min: CreatedAggregationFn<any, any>;
-  max: CreatedAggregationFn<any, any>;
-  extent: CreatedAggregationFn<any, any>;
-  mean: CreatedAggregationFn<any, any>;
-  median: CreatedAggregationFn<any, any>;
-  unique: CreatedAggregationFn<any, any>;
-  uniqueCount: CreatedAggregationFn<any, any>;
-  count: typeof aggregationFn_count;
-  first: typeof aggregationFn_first;
-  last: typeof aggregationFn_last;
-};
-type BuiltInAggregationFn = keyof typeof aggregationFns;
-//#endregion
-export { BuiltInAggregationFn, aggregationFn_count, aggregationFn_extent, aggregationFn_first, aggregationFn_last, aggregationFn_max, aggregationFn_mean, aggregationFn_median, aggregationFn_min, aggregationFn_sum, aggregationFn_unique, aggregationFn_uniqueCount, aggregationFns, constructAggregationFn };
-//# sourceMappingURL=aggregationFns.d.ts.map