@tanstack/table-core 9.0.0-alpha.6 → 9.0.0-beta.1

package/dist/features/column-filtering/filterRowsUtils.js

@@ -0,0 +1,81 @@
+import { constructRow } from "../../core/rows/constructRow.js";
+
+//#region src/features/column-filtering/filterRowsUtils.ts
+/**
+* Filters a row model with the supplied row predicate.
+*
+* The helper supports both filtering from leaf rows upward and filtering parents before descendants, depending on table options.
+*/
+function filterRows(rows, filterRowImpl, table) {
+	if (table.options.filterFromLeafRows) return filterRowModelFromLeafs(rows, filterRowImpl, table);
+	return filterRowModelFromRoot(rows, filterRowImpl, table);
+}
+function filterRowModelFromLeafs(rowsToFilter, filterRow, table) {
+	const newFilteredFlatRows = [];
+	const newFilteredRowsById = {};
+	const maxDepth = table.options.maxLeafRowFilterDepth ?? 100;
+	const recurseFilterRows = (rowsToFilter, depth = 0) => {
+		const filteredRows = [];
+		for (let row of rowsToFilter) {
+			const newRow = constructRow(table, row.id, row.original, row.index, row.depth, void 0, row.parentId);
+			newRow.columnFilters = row.columnFilters;
+			if (row.subRows.length && depth < maxDepth) {
+				newRow.subRows = recurseFilterRows(row.subRows, depth + 1);
+				row = newRow;
+				if (filterRow(row) && !newRow.subRows.length) {
+					filteredRows.push(row);
+					newFilteredRowsById[row.id] = row;
+					newFilteredFlatRows.push(row);
+					continue;
+				}
+				if (filterRow(row) || newRow.subRows.length) {
+					filteredRows.push(row);
+					newFilteredRowsById[row.id] = row;
+					newFilteredFlatRows.push(row);
+					continue;
+				}
+			} else {
+				row = newRow;
+				if (filterRow(row)) {
+					filteredRows.push(row);
+					newFilteredRowsById[row.id] = row;
+					newFilteredFlatRows.push(row);
+				}
+			}
+		}
+		return filteredRows;
+	};
+	return {
+		rows: recurseFilterRows(rowsToFilter),
+		flatRows: newFilteredFlatRows,
+		rowsById: newFilteredRowsById
+	};
+}
+function filterRowModelFromRoot(rowsToFilter, filterRow, table) {
+	const newFilteredFlatRows = [];
+	const newFilteredRowsById = {};
+	const maxDepth = table.options.maxLeafRowFilterDepth ?? 100;
+	const recurseFilterRows = (rowsToFilter, depth = 0) => {
+		const filteredRows = [];
+		for (let row of rowsToFilter) if (filterRow(row)) {
+			if (row.subRows.length && depth < maxDepth) {
+				const newRow = constructRow(table, row.id, row.original, row.index, row.depth, void 0, row.parentId);
+				newRow.subRows = recurseFilterRows(row.subRows, depth + 1);
+				row = newRow;
+			}
+			filteredRows.push(row);
+			newFilteredFlatRows.push(row);
+			newFilteredRowsById[row.id] = row;
+		}
+		return filteredRows;
+	};
+	return {
+		rows: recurseFilterRows(rowsToFilter),
+		flatRows: newFilteredFlatRows,
+		rowsById: newFilteredRowsById
+	};
+}
+
+//#endregion
+export { filterRows };
+//# sourceMappingURL=filterRowsUtils.js.map

package/dist/features/column-filtering/filterRowsUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterRowsUtils.js","names":[],"sources":["../../../src/features/column-filtering/filterRowsUtils.ts"],"sourcesContent":["import { constructRow } from '../../core/rows/constructRow'\nimport type { Row_ColumnFiltering } from './columnFilteringFeature.types'\nimport type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'\nimport type { Row } from '../../types/Row'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\n\n/**\n * Filters a row model with the supplied row predicate.\n *\n * The helper supports both filtering from leaf rows upward and filtering parents before descendants, depending on table options.\n */\nexport function filterRows<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rows: Array<Row<TFeatures, TData>>,\n  filterRowImpl: (row: Row<TFeatures, TData>) => any,\n  table: Table_Internal<TFeatures, TData>,\n) {\n  if (table.options.filterFromLeafRows) {\n    return filterRowModelFromLeafs(rows, filterRowImpl, table)\n  }\n\n  return filterRowModelFromRoot(rows, filterRowImpl, table)\n}\n\nfunction filterRowModelFromLeafs<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowsToFilter: Array<Row<TFeatures, TData>>,\n  filterRow: (\n    row: Row<TFeatures, TData>,\n  ) => Array<Row<TFeatures, TData>> | undefined,\n  table: Table_Internal<TFeatures, TData>,\n): RowModel<TFeatures, TData> {\n  const newFilteredFlatRows: Array<Row<TFeatures, TData>> = []\n  const newFilteredRowsById: Record<string, Row<TFeatures, TData>> = {}\n  const maxDepth = table.options.maxLeafRowFilterDepth ?? 100\n\n  const recurseFilterRows = (\n    rowsToFilter: Array<\n      Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>\n    >,\n    depth = 0,\n  ) => {\n    const filteredRows: Array<Row<TFeatures, TData>> &\n      Partial<Row_ColumnFiltering<TFeatures, TData>> = []\n\n    // Filter from children up first\n    for (let row of rowsToFilter) {\n      const newRow = constructRow(\n        table,\n        row.id,\n        row.original,\n        row.index,\n        row.depth,\n        undefined,\n        row.parentId,\n      ) as Row<TFeatures, TData> &\n        Partial<Row_ColumnFiltering<TFeatures, TData>>\n      newRow.columnFilters = row.columnFilters\n\n      if (row.subRows.length && depth < maxDepth) {\n        newRow.subRows = recurseFilterRows(row.subRows, depth + 1)\n        row = newRow\n\n        if (filterRow(row) && !newRow.subRows.length) {\n          filteredRows.push(row)\n          newFilteredRowsById[row.id] = row\n          newFilteredFlatRows.push(row)\n          continue\n        }\n\n        if (filterRow(row) || newRow.subRows.length) {\n          filteredRows.push(row)\n          newFilteredRowsById[row.id] = row\n          newFilteredFlatRows.push(row)\n          continue\n        }\n      } else {\n        row = newRow\n        if (filterRow(row)) {\n          filteredRows.push(row)\n          newFilteredRowsById[row.id] = row\n          newFilteredFlatRows.push(row)\n        }\n      }\n    }\n\n    return filteredRows\n  }\n\n  return {\n    rows: recurseFilterRows(rowsToFilter),\n    flatRows: newFilteredFlatRows,\n    rowsById: newFilteredRowsById,\n  }\n}\n\nfunction filterRowModelFromRoot<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowsToFilter: Array<Row<TFeatures, TData>>,\n  filterRow: (row: Row<TFeatures, TData>) => any,\n  table: Table_Internal<TFeatures, TData>,\n): RowModel<TFeatures, TData> {\n  const newFilteredFlatRows: Array<Row<TFeatures, TData>> = []\n  const newFilteredRowsById: Record<string, Row<TFeatures, TData>> = {}\n  const maxDepth = table.options.maxLeafRowFilterDepth ?? 100\n\n  // Filters top level and nested rows\n  const recurseFilterRows = (\n    rowsToFilter: Array<Row<TFeatures, TData>>,\n    depth = 0,\n  ) => {\n    // Filter from parents downward first\n\n    const filteredRows: Array<Row<TFeatures, TData>> = []\n\n    // Apply the filter to any subRows\n    for (let row of rowsToFilter) {\n      const pass = filterRow(row)\n\n      if (pass) {\n        if (row.subRows.length && depth < maxDepth) {\n          const newRow = constructRow(\n            table,\n            row.id,\n            row.original,\n            row.index,\n            row.depth,\n            undefined,\n            row.parentId,\n          )\n          newRow.subRows = recurseFilterRows(row.subRows, depth + 1)\n          row = newRow\n        }\n\n        filteredRows.push(row)\n        newFilteredFlatRows.push(row)\n        newFilteredRowsById[row.id] = row\n      }\n    }\n\n    return filteredRows\n  }\n\n  return {\n    rows: recurseFilterRows(rowsToFilter),\n    flatRows: newFilteredFlatRows,\n    rowsById: newFilteredRowsById,\n  }\n}\n"],"mappings":";;;;;;;;AAaA,SAAgB,WAId,MACA,eACA,OACA;CACA,IAAI,MAAM,QAAQ,oBAChB,OAAO,wBAAwB,MAAM,eAAe,KAAK;CAG3D,OAAO,uBAAuB,MAAM,eAAe,KAAK;AAC1D;AAEA,SAAS,wBAIP,cACA,WAGA,OAC4B;CAC5B,MAAM,sBAAoD,CAAC;CAC3D,MAAM,sBAA6D,CAAC;CACpE,MAAM,WAAW,MAAM,QAAQ,yBAAyB;CAExD,MAAM,qBACJ,cAGA,QAAQ,MACL;EACH,MAAM,eAC6C,CAAC;EAGpD,KAAK,IAAI,OAAO,cAAc;GAC5B,MAAM,SAAS,aACb,OACA,IAAI,IACJ,IAAI,UACJ,IAAI,OACJ,IAAI,OACJ,QACA,IAAI,QACN;GAEA,OAAO,gBAAgB,IAAI;GAE3B,IAAI,IAAI,QAAQ,UAAU,QAAQ,UAAU;IAC1C,OAAO,UAAU,kBAAkB,IAAI,SAAS,QAAQ,CAAC;IACzD,MAAM;IAEN,IAAI,UAAU,GAAG,KAAK,CAAC,OAAO,QAAQ,QAAQ;KAC5C,aAAa,KAAK,GAAG;KACrB,oBAAoB,IAAI,MAAM;KAC9B,oBAAoB,KAAK,GAAG;KAC5B;IACF;IAEA,IAAI,UAAU,GAAG,KAAK,OAAO,QAAQ,QAAQ;KAC3C,aAAa,KAAK,GAAG;KACrB,oBAAoB,IAAI,MAAM;KAC9B,oBAAoB,KAAK,GAAG;KAC5B;IACF;GACF,OAAO;IACL,MAAM;IACN,IAAI,UAAU,GAAG,GAAG;KAClB,aAAa,KAAK,GAAG;KACrB,oBAAoB,IAAI,MAAM;KAC9B,oBAAoB,KAAK,GAAG;IAC9B;GACF;EACF;EAEA,OAAO;CACT;CAEA,OAAO;EACL,MAAM,kBAAkB,YAAY;EACpC,UAAU;EACV,UAAU;CACZ;AACF;AAEA,SAAS,uBAIP,cACA,WACA,OAC4B;CAC5B,MAAM,sBAAoD,CAAC;CAC3D,MAAM,sBAA6D,CAAC;CACpE,MAAM,WAAW,MAAM,QAAQ,yBAAyB;CAGxD,MAAM,qBACJ,cACA,QAAQ,MACL;EAGH,MAAM,eAA6C,CAAC;EAGpD,KAAK,IAAI,OAAO,cAGd,IAFa,UAAU,GAEhB,GAAG;GACR,IAAI,IAAI,QAAQ,UAAU,QAAQ,UAAU;IAC1C,MAAM,SAAS,aACb,OACA,IAAI,IACJ,IAAI,UACJ,IAAI,OACJ,IAAI,OACJ,QACA,IAAI,QACN;IACA,OAAO,UAAU,kBAAkB,IAAI,SAAS,QAAQ,CAAC;IACzD,MAAM;GACR;GAEA,aAAa,KAAK,GAAG;GACrB,oBAAoB,KAAK,GAAG;GAC5B,oBAAoB,IAAI,MAAM;EAChC;EAGF,OAAO;CACT;CAEA,OAAO;EACL,MAAM,kBAAkB,YAAY;EACpC,UAAU;EACV,UAAU;CACZ;AACF"}

package/dist/features/column-grouping/columnGroupingFeature.cjs

@@ -0,0 +1,79 @@
+const require_utils = require('../../utils.cjs');
+const require_columnGroupingFeature_utils = require('./columnGroupingFeature.utils.cjs');
+
+//#region src/features/column-grouping/columnGroupingFeature.ts
+/**
+* Creates the stock column grouping feature.
+*
+* The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+*/
+function constructColumnGroupingFeature() {
+	return {
+		getInitialState: (initialState) => {
+			return {
+				grouping: require_columnGroupingFeature_utils.getDefaultGroupingState(),
+				...initialState
+			};
+		},
+		getDefaultColumnDef: () => {
+			return {
+				aggregatedCell: ({ getValue }) => {
+					var _getValue, _getValue$toString;
+					return ((_getValue = getValue()) === null || _getValue === void 0 || (_getValue$toString = _getValue.toString) === null || _getValue$toString === void 0 ? void 0 : _getValue$toString.call(_getValue)) ?? null;
+				},
+				aggregationFn: "auto"
+			};
+		},
+		getDefaultTableOptions: (table) => {
+			return {
+				onGroupingChange: require_utils.makeStateUpdater("grouping", table),
+				groupedColumnMode: "reorder"
+			};
+		},
+		assignCellPrototype: (prototype, table) => {
+			require_utils.assignPrototypeAPIs("columnGroupingFeature", prototype, table, {
+				cell_getIsGrouped: { fn: (cell) => require_columnGroupingFeature_utils.cell_getIsGrouped(cell) },
+				cell_getIsPlaceholder: { fn: (cell) => require_columnGroupingFeature_utils.cell_getIsPlaceholder(cell) },
+				cell_getIsAggregated: { fn: (cell) => require_columnGroupingFeature_utils.cell_getIsAggregated(cell) }
+			});
+		},
+		assignColumnPrototype: (prototype, table) => {
+			require_utils.assignPrototypeAPIs("columnGroupingFeature", prototype, table, {
+				column_toggleGrouping: { fn: (column) => require_columnGroupingFeature_utils.column_toggleGrouping(column) },
+				column_getCanGroup: { fn: (column) => require_columnGroupingFeature_utils.column_getCanGroup(column) },
+				column_getIsGrouped: { fn: (column) => require_columnGroupingFeature_utils.column_getIsGrouped(column) },
+				column_getGroupedIndex: { fn: (column) => require_columnGroupingFeature_utils.column_getGroupedIndex(column) },
+				column_getToggleGroupingHandler: { fn: (column) => require_columnGroupingFeature_utils.column_getToggleGroupingHandler(column) },
+				column_getAutoAggregationFn: { fn: (column) => require_columnGroupingFeature_utils.column_getAutoAggregationFn(column) },
+				column_getAggregationFn: { fn: (column) => require_columnGroupingFeature_utils.column_getAggregationFn(column) }
+			});
+		},
+		assignRowPrototype: (prototype, table) => {
+			require_utils.assignPrototypeAPIs("columnGroupingFeature", prototype, table, {
+				row_getIsGrouped: { fn: (row) => require_columnGroupingFeature_utils.row_getIsGrouped(row) },
+				row_getGroupingValue: { fn: (row, columnId) => require_columnGroupingFeature_utils.row_getGroupingValue(row, columnId) }
+			});
+		},
+		initRowInstanceData: (row) => {
+			row._groupingValuesCache = {};
+		},
+		constructTableAPIs: (table) => {
+			require_utils.assignTableAPIs("columnGroupingFeature", table, {
+				table_setGrouping: { fn: (updater) => require_columnGroupingFeature_utils.table_setGrouping(table, updater) },
+				table_resetGrouping: { fn: (defaultState) => require_columnGroupingFeature_utils.table_resetGrouping(table, defaultState) }
+			});
+		}
+	};
+}
+/**
+* The stock column grouping feature.
+*
+* Register this feature to add grouping state, aggregation defaults, grouped
+* row-model support, and table/row/column/cell grouping APIs.
+*/
+const columnGroupingFeature = constructColumnGroupingFeature();
+
+//#endregion
+exports.columnGroupingFeature = columnGroupingFeature;
+exports.constructColumnGroupingFeature = constructColumnGroupingFeature;
+//# sourceMappingURL=columnGroupingFeature.cjs.map

package/dist/features/column-grouping/columnGroupingFeature.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnGroupingFeature.cjs","names":["getDefaultGroupingState","makeStateUpdater","cell_getIsGrouped","cell_getIsPlaceholder","cell_getIsAggregated","column_toggleGrouping","column_getCanGroup","column_getIsGrouped","column_getGroupedIndex","column_getToggleGroupingHandler","column_getAutoAggregationFn","column_getAggregationFn","row_getIsGrouped","row_getGroupingValue","table_setGrouping","table_resetGrouping"],"sources":["../../../src/features/column-grouping/columnGroupingFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  cell_getIsAggregated,\n  cell_getIsGrouped,\n  cell_getIsPlaceholder,\n  column_getAggregationFn,\n  column_getAutoAggregationFn,\n  column_getCanGroup,\n  column_getGroupedIndex,\n  column_getIsGrouped,\n  column_getToggleGroupingHandler,\n  column_toggleGrouping,\n  getDefaultGroupingState,\n  row_getGroupingValue,\n  row_getIsGrouped,\n  table_resetGrouping,\n  table_setGrouping,\n} from './columnGroupingFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type {\n//   CachedRowModel_Grouped,\n//   Cell_ColumnGrouping,\n//   ColumnDef_ColumnGrouping,\n//   Column_ColumnGrouping,\n//   CreateRowModel_Grouped,\n//   RowModelFns_ColumnGrouping,\n//   Row_ColumnGrouping,\n//   TableOptions_ColumnGrouping,\n//   TableState_ColumnGrouping,\n//   Table_ColumnGrouping,\n// } from './columnGroupingFeature.types'\n\nexport interface ColumnGroupingFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // CachedRowModel: CachedRowModel_Grouped<TFeatures, TData>\n  // Cell: Cell_ColumnGrouping\n  // Column: Column_ColumnGrouping<TFeatures, TData>\n  // ColumnDef: ColumnDef_ColumnGrouping<TFeatures, TData>\n  // CreateRowModels: CreateRowModel_Grouped<TFeatures, TData>\n  // Row: Row_ColumnGrouping\n  // RowModelFns: RowModelFns_ColumnGrouping<TFeatures, TData>\n  // Table: Table_ColumnGrouping<TFeatures, TData>\n  // TableOptions: TableOptions_ColumnGrouping\n  // TableState: TableState_ColumnGrouping\n}\n\n/**\n * Creates the stock column grouping feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructColumnGroupingFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<ColumnGroupingFeatureConstructors<TFeatures, TData>> {\n  return {\n    getInitialState: (initialState) => {\n      return {\n        grouping: getDefaultGroupingState(),\n        ...initialState,\n      }\n    },\n\n    getDefaultColumnDef: () => {\n      return {\n        aggregatedCell: ({ getValue }: any) => getValue()?.toString?.() ?? null,\n        aggregationFn: 'auto',\n      }\n    },\n\n    getDefaultTableOptions: (table) => {\n      return {\n        onGroupingChange: makeStateUpdater('grouping', table),\n        groupedColumnMode: 'reorder',\n      }\n    },\n\n    assignCellPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {\n        cell_getIsGrouped: {\n          fn: (cell) => cell_getIsGrouped(cell),\n        },\n        cell_getIsPlaceholder: {\n          fn: (cell) => cell_getIsPlaceholder(cell),\n        },\n        cell_getIsAggregated: {\n          fn: (cell) => cell_getIsAggregated(cell),\n        },\n      })\n    },\n\n    assignColumnPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {\n        column_toggleGrouping: {\n          fn: (column) => column_toggleGrouping(column),\n        },\n        column_getCanGroup: {\n          fn: (column) => column_getCanGroup(column),\n        },\n        column_getIsGrouped: {\n          fn: (column) => column_getIsGrouped(column),\n        },\n        column_getGroupedIndex: {\n          fn: (column) => column_getGroupedIndex(column),\n        },\n        column_getToggleGroupingHandler: {\n          fn: (column) => column_getToggleGroupingHandler(column),\n        },\n        column_getAutoAggregationFn: {\n          fn: (column) => column_getAutoAggregationFn(column),\n        },\n        column_getAggregationFn: {\n          fn: (column) => column_getAggregationFn(column),\n        },\n      })\n    },\n\n    assignRowPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {\n        row_getIsGrouped: {\n          fn: (row) => row_getIsGrouped(row),\n        },\n        row_getGroupingValue: {\n          fn: (row, columnId) => row_getGroupingValue(row, columnId),\n        },\n      })\n    },\n\n    initRowInstanceData: (row) => {\n      ;(row as any)._groupingValuesCache = {}\n    },\n\n    constructTableAPIs: (table) => {\n      assignTableAPIs('columnGroupingFeature', table, {\n        table_setGrouping: {\n          fn: (updater) => table_setGrouping(table, updater),\n        },\n        table_resetGrouping: {\n          fn: (defaultState) => table_resetGrouping(table, defaultState),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The stock column grouping feature.\n *\n * Register this feature to add grouping state, aggregation defaults, grouped\n * row-model support, and table/row/column/cell grouping APIs.\n */\nexport const columnGroupingFeature = constructColumnGroupingFeature()\n"],"mappings":";;;;;;;;;AA0DA,SAAgB,iCAGuD;CACrE,OAAO;EACL,kBAAkB,iBAAiB;GACjC,OAAO;IACL,UAAUA,4DAAwB;IAClC,GAAG;GACL;EACF;EAEA,2BAA2B;GACzB,OAAO;IACL,iBAAiB,EAAE,eAAoB;;mCAAS,uEAAG,gGAAW,MAAK;IAAG;IACtE,eAAe;GACjB;EACF;EAEA,yBAAyB,UAAU;GACjC,OAAO;IACL,kBAAkBC,+BAAiB,YAAY,KAAK;IACpD,mBAAmB;GACrB;EACF;EAEA,sBAAsB,WAAW,UAAU;GACzC,kCAAoB,yBAAyB,WAAW,OAAO;IAC7D,mBAAmB,EACjB,KAAK,SAASC,sDAAkB,IAAI,EACtC;IACA,uBAAuB,EACrB,KAAK,SAASC,0DAAsB,IAAI,EAC1C;IACA,sBAAsB,EACpB,KAAK,SAASC,yDAAqB,IAAI,EACzC;GACF,CAAC;EACH;EAEA,wBAAwB,WAAW,UAAU;GAC3C,kCAAoB,yBAAyB,WAAW,OAAO;IAC7D,uBAAuB,EACrB,KAAK,WAAWC,0DAAsB,MAAM,EAC9C;IACA,oBAAoB,EAClB,KAAK,WAAWC,uDAAmB,MAAM,EAC3C;IACA,qBAAqB,EACnB,KAAK,WAAWC,wDAAoB,MAAM,EAC5C;IACA,wBAAwB,EACtB,KAAK,WAAWC,2DAAuB,MAAM,EAC/C;IACA,iCAAiC,EAC/B,KAAK,WAAWC,oEAAgC,MAAM,EACxD;IACA,6BAA6B,EAC3B,KAAK,WAAWC,gEAA4B,MAAM,EACpD;IACA,yBAAyB,EACvB,KAAK,WAAWC,4DAAwB,MAAM,EAChD;GACF,CAAC;EACH;EAEA,qBAAqB,WAAW,UAAU;GACxC,kCAAoB,yBAAyB,WAAW,OAAO;IAC7D,kBAAkB,EAChB,KAAK,QAAQC,qDAAiB,GAAG,EACnC;IACA,sBAAsB,EACpB,KAAK,KAAK,aAAaC,yDAAqB,KAAK,QAAQ,EAC3D;GACF,CAAC;EACH;EAEA,sBAAsB,QAAQ;GAC3B,AAAC,IAAY,uBAAuB,CAAC;EACxC;EAEA,qBAAqB,UAAU;GAC7B,8BAAgB,yBAAyB,OAAO;IAC9C,mBAAmB,EACjB,KAAK,YAAYC,sDAAkB,OAAO,OAAO,EACnD;IACA,qBAAqB,EACnB,KAAK,iBAAiBC,wDAAoB,OAAO,YAAY,EAC/D;GACF,CAAC;EACH;CACF;AACF;;;;;;;AAQA,MAAa,wBAAwB,+BAA+B"}

package/dist/features/column-grouping/columnGroupingFeature.d.cts

@@ -0,0 +1,21 @@
+import { RowData } from "../../types/type-utils.cjs";
+import { TableFeature, TableFeatures } from "../../types/TableFeatures.cjs";
+
+//#region src/features/column-grouping/columnGroupingFeature.d.ts
+interface ColumnGroupingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
+/**
+ * Creates the stock column grouping feature.
+ *
+ * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ */
+declare function constructColumnGroupingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnGroupingFeatureConstructors<TFeatures, TData>>;
+/**
+ * The stock column grouping feature.
+ *
+ * Register this feature to add grouping state, aggregation defaults, grouped
+ * row-model support, and table/row/column/cell grouping APIs.
+ */
+declare const columnGroupingFeature: TableFeature<ColumnGroupingFeatureConstructors<TableFeatures, RowData>>;
+//#endregion
+export { ColumnGroupingFeatureConstructors, columnGroupingFeature, constructColumnGroupingFeature };
+//# sourceMappingURL=columnGroupingFeature.d.cts.map

package/dist/features/column-grouping/columnGroupingFeature.d.ts

@@ -0,0 +1,21 @@
+import { RowData } from "../../types/type-utils.js";
+import { TableFeature, TableFeatures } from "../../types/TableFeatures.js";
+
+//#region src/features/column-grouping/columnGroupingFeature.d.ts
+interface ColumnGroupingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
+/**
+ * Creates the stock column grouping feature.
+ *
+ * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ */
+declare function constructColumnGroupingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnGroupingFeatureConstructors<TFeatures, TData>>;
+/**
+ * The stock column grouping feature.
+ *
+ * Register this feature to add grouping state, aggregation defaults, grouped
+ * row-model support, and table/row/column/cell grouping APIs.
+ */
+declare const columnGroupingFeature: TableFeature<ColumnGroupingFeatureConstructors<TableFeatures, RowData>>;
+//#endregion
+export { ColumnGroupingFeatureConstructors, columnGroupingFeature, constructColumnGroupingFeature };
+//# sourceMappingURL=columnGroupingFeature.d.ts.map

package/dist/features/column-grouping/columnGroupingFeature.js

@@ -0,0 +1,78 @@
+import { assignPrototypeAPIs, assignTableAPIs, makeStateUpdater } from "../../utils.js";
+import { cell_getIsAggregated, cell_getIsGrouped, cell_getIsPlaceholder, column_getAggregationFn, column_getAutoAggregationFn, column_getCanGroup, column_getGroupedIndex, column_getIsGrouped, column_getToggleGroupingHandler, column_toggleGrouping, getDefaultGroupingState, row_getGroupingValue, row_getIsGrouped, table_resetGrouping, table_setGrouping } from "./columnGroupingFeature.utils.js";
+
+//#region src/features/column-grouping/columnGroupingFeature.ts
+/**
+* Creates the stock column grouping feature.
+*
+* The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+*/
+function constructColumnGroupingFeature() {
+	return {
+		getInitialState: (initialState) => {
+			return {
+				grouping: getDefaultGroupingState(),
+				...initialState
+			};
+		},
+		getDefaultColumnDef: () => {
+			return {
+				aggregatedCell: ({ getValue }) => {
+					var _getValue, _getValue$toString;
+					return ((_getValue = getValue()) === null || _getValue === void 0 || (_getValue$toString = _getValue.toString) === null || _getValue$toString === void 0 ? void 0 : _getValue$toString.call(_getValue)) ?? null;
+				},
+				aggregationFn: "auto"
+			};
+		},
+		getDefaultTableOptions: (table) => {
+			return {
+				onGroupingChange: makeStateUpdater("grouping", table),
+				groupedColumnMode: "reorder"
+			};
+		},
+		assignCellPrototype: (prototype, table) => {
+			assignPrototypeAPIs("columnGroupingFeature", prototype, table, {
+				cell_getIsGrouped: { fn: (cell) => cell_getIsGrouped(cell) },
+				cell_getIsPlaceholder: { fn: (cell) => cell_getIsPlaceholder(cell) },
+				cell_getIsAggregated: { fn: (cell) => cell_getIsAggregated(cell) }
+			});
+		},
+		assignColumnPrototype: (prototype, table) => {
+			assignPrototypeAPIs("columnGroupingFeature", prototype, table, {
+				column_toggleGrouping: { fn: (column) => column_toggleGrouping(column) },
+				column_getCanGroup: { fn: (column) => column_getCanGroup(column) },
+				column_getIsGrouped: { fn: (column) => column_getIsGrouped(column) },
+				column_getGroupedIndex: { fn: (column) => column_getGroupedIndex(column) },
+				column_getToggleGroupingHandler: { fn: (column) => column_getToggleGroupingHandler(column) },
+				column_getAutoAggregationFn: { fn: (column) => column_getAutoAggregationFn(column) },
+				column_getAggregationFn: { fn: (column) => column_getAggregationFn(column) }
+			});
+		},
+		assignRowPrototype: (prototype, table) => {
+			assignPrototypeAPIs("columnGroupingFeature", prototype, table, {
+				row_getIsGrouped: { fn: (row) => row_getIsGrouped(row) },
+				row_getGroupingValue: { fn: (row, columnId) => row_getGroupingValue(row, columnId) }
+			});
+		},
+		initRowInstanceData: (row) => {
+			row._groupingValuesCache = {};
+		},
+		constructTableAPIs: (table) => {
+			assignTableAPIs("columnGroupingFeature", table, {
+				table_setGrouping: { fn: (updater) => table_setGrouping(table, updater) },
+				table_resetGrouping: { fn: (defaultState) => table_resetGrouping(table, defaultState) }
+			});
+		}
+	};
+}
+/**
+* The stock column grouping feature.
+*
+* Register this feature to add grouping state, aggregation defaults, grouped
+* row-model support, and table/row/column/cell grouping APIs.
+*/
+const columnGroupingFeature = constructColumnGroupingFeature();
+
+//#endregion
+export { columnGroupingFeature, constructColumnGroupingFeature };
+//# sourceMappingURL=columnGroupingFeature.js.map

package/dist/features/column-grouping/columnGroupingFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnGroupingFeature.js","names":[],"sources":["../../../src/features/column-grouping/columnGroupingFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  cell_getIsAggregated,\n  cell_getIsGrouped,\n  cell_getIsPlaceholder,\n  column_getAggregationFn,\n  column_getAutoAggregationFn,\n  column_getCanGroup,\n  column_getGroupedIndex,\n  column_getIsGrouped,\n  column_getToggleGroupingHandler,\n  column_toggleGrouping,\n  getDefaultGroupingState,\n  row_getGroupingValue,\n  row_getIsGrouped,\n  table_resetGrouping,\n  table_setGrouping,\n} from './columnGroupingFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type {\n//   CachedRowModel_Grouped,\n//   Cell_ColumnGrouping,\n//   ColumnDef_ColumnGrouping,\n//   Column_ColumnGrouping,\n//   CreateRowModel_Grouped,\n//   RowModelFns_ColumnGrouping,\n//   Row_ColumnGrouping,\n//   TableOptions_ColumnGrouping,\n//   TableState_ColumnGrouping,\n//   Table_ColumnGrouping,\n// } from './columnGroupingFeature.types'\n\nexport interface ColumnGroupingFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // CachedRowModel: CachedRowModel_Grouped<TFeatures, TData>\n  // Cell: Cell_ColumnGrouping\n  // Column: Column_ColumnGrouping<TFeatures, TData>\n  // ColumnDef: ColumnDef_ColumnGrouping<TFeatures, TData>\n  // CreateRowModels: CreateRowModel_Grouped<TFeatures, TData>\n  // Row: Row_ColumnGrouping\n  // RowModelFns: RowModelFns_ColumnGrouping<TFeatures, TData>\n  // Table: Table_ColumnGrouping<TFeatures, TData>\n  // TableOptions: TableOptions_ColumnGrouping\n  // TableState: TableState_ColumnGrouping\n}\n\n/**\n * Creates the stock column grouping feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructColumnGroupingFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<ColumnGroupingFeatureConstructors<TFeatures, TData>> {\n  return {\n    getInitialState: (initialState) => {\n      return {\n        grouping: getDefaultGroupingState(),\n        ...initialState,\n      }\n    },\n\n    getDefaultColumnDef: () => {\n      return {\n        aggregatedCell: ({ getValue }: any) => getValue()?.toString?.() ?? null,\n        aggregationFn: 'auto',\n      }\n    },\n\n    getDefaultTableOptions: (table) => {\n      return {\n        onGroupingChange: makeStateUpdater('grouping', table),\n        groupedColumnMode: 'reorder',\n      }\n    },\n\n    assignCellPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {\n        cell_getIsGrouped: {\n          fn: (cell) => cell_getIsGrouped(cell),\n        },\n        cell_getIsPlaceholder: {\n          fn: (cell) => cell_getIsPlaceholder(cell),\n        },\n        cell_getIsAggregated: {\n          fn: (cell) => cell_getIsAggregated(cell),\n        },\n      })\n    },\n\n    assignColumnPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {\n        column_toggleGrouping: {\n          fn: (column) => column_toggleGrouping(column),\n        },\n        column_getCanGroup: {\n          fn: (column) => column_getCanGroup(column),\n        },\n        column_getIsGrouped: {\n          fn: (column) => column_getIsGrouped(column),\n        },\n        column_getGroupedIndex: {\n          fn: (column) => column_getGroupedIndex(column),\n        },\n        column_getToggleGroupingHandler: {\n          fn: (column) => column_getToggleGroupingHandler(column),\n        },\n        column_getAutoAggregationFn: {\n          fn: (column) => column_getAutoAggregationFn(column),\n        },\n        column_getAggregationFn: {\n          fn: (column) => column_getAggregationFn(column),\n        },\n      })\n    },\n\n    assignRowPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {\n        row_getIsGrouped: {\n          fn: (row) => row_getIsGrouped(row),\n        },\n        row_getGroupingValue: {\n          fn: (row, columnId) => row_getGroupingValue(row, columnId),\n        },\n      })\n    },\n\n    initRowInstanceData: (row) => {\n      ;(row as any)._groupingValuesCache = {}\n    },\n\n    constructTableAPIs: (table) => {\n      assignTableAPIs('columnGroupingFeature', table, {\n        table_setGrouping: {\n          fn: (updater) => table_setGrouping(table, updater),\n        },\n        table_resetGrouping: {\n          fn: (defaultState) => table_resetGrouping(table, defaultState),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The stock column grouping feature.\n *\n * Register this feature to add grouping state, aggregation defaults, grouped\n * row-model support, and table/row/column/cell grouping APIs.\n */\nexport const columnGroupingFeature = constructColumnGroupingFeature()\n"],"mappings":";;;;;;;;;AA0DA,SAAgB,iCAGuD;CACrE,OAAO;EACL,kBAAkB,iBAAiB;GACjC,OAAO;IACL,UAAU,wBAAwB;IAClC,GAAG;GACL;EACF;EAEA,2BAA2B;GACzB,OAAO;IACL,iBAAiB,EAAE,eAAoB;;mCAAS,uEAAG,gGAAW,MAAK;IAAG;IACtE,eAAe;GACjB;EACF;EAEA,yBAAyB,UAAU;GACjC,OAAO;IACL,kBAAkB,iBAAiB,YAAY,KAAK;IACpD,mBAAmB;GACrB;EACF;EAEA,sBAAsB,WAAW,UAAU;GACzC,oBAAoB,yBAAyB,WAAW,OAAO;IAC7D,mBAAmB,EACjB,KAAK,SAAS,kBAAkB,IAAI,EACtC;IACA,uBAAuB,EACrB,KAAK,SAAS,sBAAsB,IAAI,EAC1C;IACA,sBAAsB,EACpB,KAAK,SAAS,qBAAqB,IAAI,EACzC;GACF,CAAC;EACH;EAEA,wBAAwB,WAAW,UAAU;GAC3C,oBAAoB,yBAAyB,WAAW,OAAO;IAC7D,uBAAuB,EACrB,KAAK,WAAW,sBAAsB,MAAM,EAC9C;IACA,oBAAoB,EAClB,KAAK,WAAW,mBAAmB,MAAM,EAC3C;IACA,qBAAqB,EACnB,KAAK,WAAW,oBAAoB,MAAM,EAC5C;IACA,wBAAwB,EACtB,KAAK,WAAW,uBAAuB,MAAM,EAC/C;IACA,iCAAiC,EAC/B,KAAK,WAAW,gCAAgC,MAAM,EACxD;IACA,6BAA6B,EAC3B,KAAK,WAAW,4BAA4B,MAAM,EACpD;IACA,yBAAyB,EACvB,KAAK,WAAW,wBAAwB,MAAM,EAChD;GACF,CAAC;EACH;EAEA,qBAAqB,WAAW,UAAU;GACxC,oBAAoB,yBAAyB,WAAW,OAAO;IAC7D,kBAAkB,EAChB,KAAK,QAAQ,iBAAiB,GAAG,EACnC;IACA,sBAAsB,EACpB,KAAK,KAAK,aAAa,qBAAqB,KAAK,QAAQ,EAC3D;GACF,CAAC;EACH;EAEA,sBAAsB,QAAQ;GAC3B,AAAC,IAAY,uBAAuB,CAAC;EACxC;EAEA,qBAAqB,UAAU;GAC7B,gBAAgB,yBAAyB,OAAO;IAC9C,mBAAmB,EACjB,KAAK,YAAY,kBAAkB,OAAO,OAAO,EACnD;IACA,qBAAqB,EACnB,KAAK,iBAAiB,oBAAoB,OAAO,YAAY,EAC/D;GACF,CAAC;EACH;CACF;AACF;;;;;;;AAQA,MAAa,wBAAwB,+BAA+B"}

package/dist/features/column-grouping/columnGroupingFeature.types.d.cts

@@ -0,0 +1,165 @@
+import { CellData, OnChangeFn, RowData, Updater } from "../../types/type-utils.cjs";
+import { Row } from "../../types/Row.cjs";
+import { ColumnDefTemplate } from "../../types/ColumnDef.cjs";
+import { TableFeatures } from "../../types/TableFeatures.cjs";
+import { Table } from "../../types/Table.cjs";
+import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.cjs";
+import { BuiltInAggregationFn } from "../../fns/aggregationFns.cjs";
+import { Cell } from "../../types/Cell.cjs";
+
+//#region src/features/column-grouping/columnGroupingFeature.types.d.ts
+type GroupingState = Array<string>;
+interface TableState_ColumnGrouping {
+  grouping: GroupingState;
+}
+interface RowModelFns_ColumnGrouping<TFeatures extends TableFeatures, TData extends RowData> {
+  aggregationFns: Record<keyof AggregationFns, AggregationFn<TFeatures, TData>>;
+}
+interface AggregationFns {}
+type AggregationFn<TFeatures extends TableFeatures, TData extends RowData> = (columnId: string, leafRows: Array<Row<TFeatures, TData>>, childRows: Array<Row<TFeatures, TData>>) => any;
+type CustomAggregationFns<TFeatures extends TableFeatures, TData extends RowData> = Record<string, AggregationFn<TFeatures, TData>>;
+type AggregationFnOption<TFeatures extends TableFeatures, TData extends RowData> = 'auto' | keyof AggregationFns | BuiltInAggregationFn | AggregationFn<TFeatures, TData>;
+interface ColumnDef_ColumnGrouping<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> {
+  /**
+   * The cell to display each row for the column if the cell is an aggregate. If a function is passed, it will be passed a props object with the context of the cell and should return the property type for your adapter (the exact type depends on the adapter being used).
+   */
+  aggregatedCell?: ColumnDefTemplate<ReturnType<Cell<TFeatures, TData, TValue>['getContext']>>;
+  /**
+   * The resolved aggregation function for the column.
+   */
+  aggregationFn?: AggregationFnOption<TFeatures, TData>;
+  /**
+   * Allows this column to be added to grouping state.
+   *
+   * Defaults to `true`; table-level `enableGrouping` must also allow grouping.
+   */
+  enableGrouping?: boolean;
+  /**
+   * Specify a value to be used for grouping rows on this column. If this option is not specified, the value derived from `accessorKey` / `accessorFn` will be used instead.
+   */
+  getGroupingValue?: (row: TData) => any;
+}
+interface Column_ColumnGrouping<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Returns the aggregation function for the column.
+   */
+  getAggregationFn: () => AggregationFn<TFeatures, TData> | undefined;
+  /**
+   * Returns the automatically inferred aggregation function for the column.
+   */
+  getAutoAggregationFn: () => AggregationFn<TFeatures, TData> | undefined;
+  /**
+   * Checks whether this column can currently be grouped.
+   */
+  getCanGroup: () => boolean;
+  /**
+   * Finds this column's position in the ordered grouping state.
+   */
+  getGroupedIndex: () => number;
+  /**
+   * Checks whether this column id is present in grouping state.
+   */
+  getIsGrouped: () => boolean;
+  /**
+   * Returns a function that toggles the grouping state of the column. This is useful for passing to the `onClick` prop of a button.
+   */
+  getToggleGroupingHandler: () => () => void;
+  /**
+   * Toggles the grouping state of the column.
+   */
+  toggleGrouping: () => void;
+}
+interface Row_ColumnGrouping {
+  _groupingValuesCache: Record<string, any>;
+  /**
+   * Reads the value used to group this row for a column id.
+   */
+  getGroupingValue: (columnId: string) => unknown;
+  /**
+   * Checks whether this row represents a grouped row.
+   */
+  getIsGrouped: () => boolean;
+  /**
+   * If this row is grouped, this is the id of the column that this row is grouped by.
+   */
+  groupingColumnId?: string;
+  /**
+   * If this row is grouped, this is the unique/shared value for the `groupingColumnId` for all of the rows in this group.
+   */
+  groupingValue?: unknown;
+}
+interface Cell_ColumnGrouping {
+  /**
+   * Checks whether this cell should render an aggregated value.
+   */
+  getIsAggregated: () => boolean;
+  /**
+   * Checks whether this cell represents the active grouping column.
+   */
+  getIsGrouped: () => boolean;
+  /**
+   * Checks whether this cell is hidden as a grouping placeholder.
+   */
+  getIsPlaceholder: () => boolean;
+}
+interface ColumnDefaultOptions {
+  enableGrouping: boolean;
+  onGroupingChange: OnChangeFn<GroupingState>;
+}
+interface TableOptions_ColumnGrouping {
+  /**
+   * Allows columns to be grouped for this table.
+   */
+  enableGrouping?: boolean;
+  /**
+   * Grouping columns are automatically reordered by default to the start of the columns list. If you would rather remove them or leave them as-is, set the appropriate mode here.
+   */
+  groupedColumnMode?: false | 'reorder' | 'remove';
+  /**
+   * Enables manual grouping. If this option is set to `true`, the table will not automatically group rows using `getGroupedRowModel()` and instead will expect you to manually group the rows before passing them to the table. This is useful if you are doing server-side grouping and aggregation.
+   */
+  manualGrouping?: boolean;
+  /**
+   * Called with an updater when grouping state changes. Pair this with
+   * `state.grouping` when using external state; external atoms can own the
+   * slice without this callback.
+   */
+  onGroupingChange?: OnChangeFn<GroupingState>;
+}
+type GroupingColumnMode = false | 'reorder' | 'remove';
+interface Table_ColumnGrouping<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Resets `grouping` to `initialState.grouping`.
+   *
+   * Pass `true` to ignore initial state and reset to `[]`.
+   */
+  resetGrouping: (defaultState?: boolean) => void;
+  /**
+   * Updates grouping state with a next ordered id array or updater function.
+   */
+  setGrouping: (updater: Updater<GroupingState>) => void;
+}
+interface Table_RowModels_Grouped<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Resolves the row model after grouping and aggregation have been applied.
+   */
+  getGroupedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Reads the row model immediately before grouping.
+   */
+  getPreGroupedRowModel: () => RowModel<TFeatures, TData>;
+}
+interface CreateRowModel_Grouped<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Factory used to retrieve the grouped row model. If using server-side
+   * grouping, this is not required. To use client-side grouping, pass
+   * `createGroupedRowModel()` or implement your own factory.
+   */
+  groupedRowModel?: (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
+}
+interface CachedRowModel_Grouped<TFeatures extends TableFeatures, TData extends RowData> {
+  groupedRowModel: () => RowModel<TFeatures, TData>;
+}
+//#endregion
+export { AggregationFn, AggregationFnOption, AggregationFns, CachedRowModel_Grouped, Cell_ColumnGrouping, ColumnDef_ColumnGrouping, ColumnDefaultOptions, Column_ColumnGrouping, CreateRowModel_Grouped, CustomAggregationFns, GroupingColumnMode, GroupingState, RowModelFns_ColumnGrouping, Row_ColumnGrouping, TableOptions_ColumnGrouping, TableState_ColumnGrouping, Table_ColumnGrouping, Table_RowModels_Grouped };
+//# sourceMappingURL=columnGroupingFeature.types.d.cts.map