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

package/dist/fns/aggregationFns.cjs

@@ -1,77 +1,127 @@
 
 //#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.
 */
-function aggregationFn_sum(columnId, _leafRows, childRows) {
-	let sumValue = 0;
-	for (let i = 0; i < childRows.length; i++) {
-		const nextValue = childRows[i].getValue(columnId);
-		sumValue += typeof nextValue === "number" ? nextValue : 0;
+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;
 	}
-	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.
 */
-function aggregationFn_min(columnId, _leafRows, childRows) {
-	let minValue;
-	for (let i = 0; i < childRows.length; i++) {
-		const value = childRows[i].getValue(columnId);
-		if (typeof value === "number" && (minValue === void 0 || value < minValue)) minValue = value;
+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;
 	}
-	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.
 */
-function aggregationFn_max(columnId, _leafRows, childRows) {
-	let maxValue;
-	for (let i = 0; i < childRows.length; i++) {
-		const value = childRows[i].getValue(columnId);
-		if (typeof value === "number" && (maxValue === void 0 || value > maxValue)) maxValue = value;
+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;
 	}
-	return maxValue;
-}
+});
 /**
 * Finds the numeric extent for a grouped column.
 *
 * Returns `[min, max]`, where each entry is `undefined` when no numeric value is
 * present.
 */
-function aggregationFn_extent(columnId, _leafRows, childRows) {
-	let minValue;
-	let maxValue;
-	for (let i = 0; i < childRows.length; i++) {
-		const value = childRows[i].getValue(columnId);
-		if (typeof value === "number") if (minValue === void 0) minValue = maxValue = value;
-		else {
-			if (minValue > value) minValue = value;
-			if (maxValue < value) maxValue = value;
+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];
 	}
-	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.
 */
-function aggregationFn_mean(columnId, leafRows) {
+const aggregationFn_mean = constructAggregationFn({ aggregate: (values) => {
 	let count = 0;
 	let sumValue = 0;
-	for (let i = 0; i < leafRows.length; i++) {
-		const value = leafRows[i].getValue(columnId);
+	for (let i = 0; i < values.length; i++) {
+		const value = values[i];
 		if (value != null && typeof value === "number") {
 			++count;
 			sumValue += value;
@@ -84,58 +134,74 @@ function aggregationFn_mean(columnId, leafRows) {
 		}
 	}
 	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`.
 */
-function aggregationFn_median(columnId, leafRows) {
-	if (!leafRows.length) return;
-	const values = new Array(leafRows.length);
-	for (let i = 0; i < leafRows.length; i++) {
-		const v = leafRows[i].getValue(columnId);
-		if (typeof v !== "number") return;
-		values[i] = v;
-	}
+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.
 */
-function aggregationFn_unique(columnId, leafRows) {
-	const set = /* @__PURE__ */ new Set();
-	for (let i = 0; i < leafRows.length; i++) set.add(leafRows[i].getValue(columnId));
-	return Array.from(set.values());
-}
+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.
 */
-function aggregationFn_uniqueCount(columnId, leafRows) {
-	const set = /* @__PURE__ */ new Set();
-	for (let i = 0; i < leafRows.length; i++) set.add(leafRows[i].getValue(columnId));
-	return set.size;
-}
+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.
 *
-* Pass this object to grouped row model creation or extend it with custom aggregation functions for grouped columns.
+* 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,
@@ -146,12 +212,16 @@ const aggregationFns = {
 	median: aggregationFn_median,
 	unique: aggregationFn_unique,
 	uniqueCount: aggregationFn_uniqueCount,
-	count: aggregationFn_count
+	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;
@@ -160,4 +230,5 @@ 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 +1 @@
-{"version":3,"file":"aggregationFns.cjs","names":[],"sources":["../../src/fns/aggregationFns.ts"],"sourcesContent":["import type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { Row } from '../types/Row'\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 function aggregationFn_sum<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  columnId: string,\n  _leafRows: Array<Row<TFeatures, TData>>,\n  childRows: Array<Row<TFeatures, TData>>,\n) {\n  // It's faster to just add the aggregations together instead of\n  // process leaf nodes individually\n  let sumValue = 0\n  for (let i = 0; i < childRows.length; i++) {\n    const nextValue = childRows[i]!.getValue(columnId)\n    sumValue += typeof nextValue === 'number' ? nextValue : 0\n  }\n  return sumValue\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 function aggregationFn_min<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  columnId: string,\n  _leafRows: Array<Row<TFeatures, TData>>,\n  childRows: Array<Row<TFeatures, TData>>,\n) {\n  let minValue: number | undefined\n\n  for (let i = 0; i < childRows.length; i++) {\n    const value = childRows[i]!.getValue(columnId)\n\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 * 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 function aggregationFn_max<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  columnId: string,\n  _leafRows: Array<Row<TFeatures, TData>>,\n  childRows: Array<Row<TFeatures, TData>>,\n) {\n  let maxValue: number | undefined\n\n  for (let i = 0; i < childRows.length; i++) {\n    const value = childRows[i]!.getValue(columnId)\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 * 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 function aggregationFn_extent<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  columnId: string,\n  _leafRows: Array<Row<TFeatures, TData>>,\n  childRows: Array<Row<TFeatures, TData>>,\n) {\n  let minValue: number | undefined\n  let maxValue: number | undefined\n\n  for (let i = 0; i < childRows.length; i++) {\n    const value = childRows[i]!.getValue(columnId)\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 * 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 function aggregationFn_mean<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  let count = 0\n  let sumValue = 0\n\n  for (let i = 0; i < leafRows.length; i++) {\n    const value = leafRows[i]!.getValue(columnId)\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 * 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 function aggregationFn_median<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  if (!leafRows.length) {\n    return\n  }\n\n  const values: Array<number> = new Array(leafRows.length)\n  for (let i = 0; i < leafRows.length; i++) {\n    const v = leafRows[i]!.getValue(columnId)\n    if (typeof v !== 'number') return\n    values[i] = v\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 * Collects unique leaf-row values for a grouped column.\n *\n * Values are compared with JavaScript `Set` semantics.\n */\nexport function aggregationFn_unique<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  const set = new Set<unknown>()\n  for (let i = 0; i < leafRows.length; i++) {\n    set.add(leafRows[i]!.getValue(columnId))\n  }\n  return Array.from(set.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 function aggregationFn_uniqueCount<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  const set = new Set<unknown>()\n  for (let i = 0; i < leafRows.length; i++) {\n    set.add(leafRows[i]!.getValue(columnId))\n  }\n  return set.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 */\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 * The built-in aggregation function registry.\n *\n * Pass this object to grouped row model creation or extend it with custom aggregation functions for grouped columns.\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}\n\nexport type BuiltInAggregationFn = keyof typeof aggregationFns\n"],"mappings":"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"}
+{"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,85 +1,139 @@
 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 function aggregationFn_sum<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, _leafRows: Array<Row<TFeatures, TData>>, childRows: Array<Row<TFeatures, TData>>): number;
+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 function aggregationFn_min<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, _leafRows: Array<Row<TFeatures, TData>>, childRows: Array<Row<TFeatures, TData>>): number | undefined;
+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 function aggregationFn_max<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, _leafRows: Array<Row<TFeatures, TData>>, childRows: Array<Row<TFeatures, TData>>): number | undefined;
+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 function aggregationFn_extent<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, _leafRows: Array<Row<TFeatures, TData>>, childRows: Array<Row<TFeatures, TData>>): (number | undefined)[];
+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 function aggregationFn_mean<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): number | undefined;
+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 function aggregationFn_median<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): number | 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 function aggregationFn_unique<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): unknown[];
+declare const aggregationFn_unique: CreatedAggregationFn<any, any>;
 /**
  * Counts unique leaf-row values for a grouped column.
  *
  * Values are compared with JavaScript `Set` semantics.
  */
-declare function aggregationFn_uniqueCount<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): number;
+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.
  *
- * Pass this object to grouped row model creation or extend it with custom aggregation functions for grouped columns.
+ * 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: typeof aggregationFn_sum;
-  min: typeof aggregationFn_min;
-  max: typeof aggregationFn_max;
-  extent: typeof aggregationFn_extent;
-  mean: typeof aggregationFn_mean;
-  median: typeof aggregationFn_median;
-  unique: typeof aggregationFn_unique;
-  uniqueCount: typeof aggregationFn_uniqueCount;
+  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_max, aggregationFn_mean, aggregationFn_median, aggregationFn_min, aggregationFn_sum, aggregationFn_unique, aggregationFn_uniqueCount, aggregationFns };
+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,85 +1,139 @@
 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 function aggregationFn_sum<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, _leafRows: Array<Row<TFeatures, TData>>, childRows: Array<Row<TFeatures, TData>>): number;
+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 function aggregationFn_min<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, _leafRows: Array<Row<TFeatures, TData>>, childRows: Array<Row<TFeatures, TData>>): number | undefined;
+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 function aggregationFn_max<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, _leafRows: Array<Row<TFeatures, TData>>, childRows: Array<Row<TFeatures, TData>>): number | undefined;
+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 function aggregationFn_extent<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, _leafRows: Array<Row<TFeatures, TData>>, childRows: Array<Row<TFeatures, TData>>): (number | undefined)[];
+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 function aggregationFn_mean<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): number | undefined;
+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 function aggregationFn_median<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): number | 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 function aggregationFn_unique<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): unknown[];
+declare const aggregationFn_unique: CreatedAggregationFn<any, any>;
 /**
  * Counts unique leaf-row values for a grouped column.
  *
  * Values are compared with JavaScript `Set` semantics.
  */
-declare function aggregationFn_uniqueCount<TFeatures extends TableFeatures, TData extends RowData>(columnId: string, leafRows: Array<Row<TFeatures, TData>>): number;
+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.
  *
- * Pass this object to grouped row model creation or extend it with custom aggregation functions for grouped columns.
+ * 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: typeof aggregationFn_sum;
-  min: typeof aggregationFn_min;
-  max: typeof aggregationFn_max;
-  extent: typeof aggregationFn_extent;
-  mean: typeof aggregationFn_mean;
-  median: typeof aggregationFn_median;
-  unique: typeof aggregationFn_unique;
-  uniqueCount: typeof aggregationFn_uniqueCount;
+  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_max, aggregationFn_mean, aggregationFn_median, aggregationFn_min, aggregationFn_sum, aggregationFn_unique, aggregationFn_uniqueCount, aggregationFns };
+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