@tanstack/table-core 9.0.0-alpha.4 → 9.0.0-alpha.41

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

@@ -0,0 +1,76 @@
+import { constructRow } from "../../core/rows/constructRow.js";
+
+//#region src/features/column-filtering/filterRowsUtils.ts
+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\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":";;;AAQA,SAAgB,WAId,MACA,eACA,OACA;AACA,KAAI,MAAM,QAAQ,mBAChB,QAAO,wBAAwB,MAAM,eAAe,MAAM;AAG5D,QAAO,uBAAuB,MAAM,eAAe,MAAM;;AAG3D,SAAS,wBAIP,cACA,WAGA,OAC4B;CAC5B,MAAM,sBAAoD,EAAE;CAC5D,MAAM,sBAA6D,EAAE;CACrE,MAAM,WAAW,MAAM,QAAQ,yBAAyB;CAExD,MAAM,qBACJ,cAGA,QAAQ,MACL;EACH,MAAM,eAC6C,EAAE;AAGrD,OAAK,IAAI,OAAO,cAAc;GAC5B,MAAM,SAAS,aACb,OACA,IAAI,IACJ,IAAI,UACJ,IAAI,OACJ,IAAI,OACJ,QACA,IAAI,SACL;AAED,UAAO,gBAAgB,IAAI;AAE3B,OAAI,IAAI,QAAQ,UAAU,QAAQ,UAAU;AAC1C,WAAO,UAAU,kBAAkB,IAAI,SAAS,QAAQ,EAAE;AAC1D,UAAM;AAEN,QAAI,UAAU,IAAI,IAAI,CAAC,OAAO,QAAQ,QAAQ;AAC5C,kBAAa,KAAK,IAAI;AACtB,yBAAoB,IAAI,MAAM;AAC9B,yBAAoB,KAAK,IAAI;AAC7B;;AAGF,QAAI,UAAU,IAAI,IAAI,OAAO,QAAQ,QAAQ;AAC3C,kBAAa,KAAK,IAAI;AACtB,yBAAoB,IAAI,MAAM;AAC9B,yBAAoB,KAAK,IAAI;AAC7B;;UAEG;AACL,UAAM;AACN,QAAI,UAAU,IAAI,EAAE;AAClB,kBAAa,KAAK,IAAI;AACtB,yBAAoB,IAAI,MAAM;AAC9B,yBAAoB,KAAK,IAAI;;;;AAKnC,SAAO;;AAGT,QAAO;EACL,MAAM,kBAAkB,aAAa;EACrC,UAAU;EACV,UAAU;EACX;;AAGH,SAAS,uBAIP,cACA,WACA,OAC4B;CAC5B,MAAM,sBAAoD,EAAE;CAC5D,MAAM,sBAA6D,EAAE;CACrE,MAAM,WAAW,MAAM,QAAQ,yBAAyB;CAGxD,MAAM,qBACJ,cACA,QAAQ,MACL;EAGH,MAAM,eAA6C,EAAE;AAGrD,OAAK,IAAI,OAAO,aAGd,KAFa,UAAU,IAEf,EAAE;AACR,OAAI,IAAI,QAAQ,UAAU,QAAQ,UAAU;IAC1C,MAAM,SAAS,aACb,OACA,IAAI,IACJ,IAAI,UACJ,IAAI,OACJ,IAAI,OACJ,QACA,IAAI,SACL;AACD,WAAO,UAAU,kBAAkB,IAAI,SAAS,QAAQ,EAAE;AAC1D,UAAM;;AAGR,gBAAa,KAAK,IAAI;AACtB,uBAAoB,KAAK,IAAI;AAC7B,uBAAoB,IAAI,MAAM;;AAIlC,SAAO;;AAGT,QAAO;EACL,MAAM,kBAAkB,aAAa;EACrC,UAAU;EACV,UAAU;EACX"}

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

@@ -0,0 +1,71 @@
+const require_utils = require('../../utils.cjs');
+const require_columnGroupingFeature_utils = require('./columnGroupingFeature.utils.cjs');
+
+//#region src/features/column-grouping/columnGroupingFeature.ts
+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 (Column) Grouping feature adds column grouping state and APIs to the table, row, column, and cell objects.
+*/
+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\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 (Column) Grouping feature adds column grouping state and APIs to the table, row, column, and cell objects.\n */\nexport const columnGroupingFeature = constructColumnGroupingFeature()\n"],"mappings":";;;;AAqDA,SAAgB,iCAGuD;AACrE,QAAO;EACL,kBAAkB,iBAAiB;AACjC,UAAO;IACL,UAAUA,6DAAyB;IACnC,GAAG;IACJ;;EAGH,2BAA2B;AACzB,UAAO;IACL,iBAAiB,EAAE,eAAoB;;oCAAU,sEAAE,iGAAY,KAAI;;IACnE,eAAe;IAChB;;EAGH,yBAAyB,UAAU;AACjC,UAAO;IACL,kBAAkBC,+BAAiB,YAAY,MAAM;IACrD,mBAAmB;IACpB;;EAGH,sBAAsB,WAAW,UAAU;AACzC,qCAAoB,yBAAyB,WAAW,OAAO;IAC7D,mBAAmB,EACjB,KAAK,SAASC,sDAAkB,KAAK,EACtC;IACD,uBAAuB,EACrB,KAAK,SAASC,0DAAsB,KAAK,EAC1C;IACD,sBAAsB,EACpB,KAAK,SAASC,yDAAqB,KAAK,EACzC;IACF,CAAC;;EAGJ,wBAAwB,WAAW,UAAU;AAC3C,qCAAoB,yBAAyB,WAAW,OAAO;IAC7D,uBAAuB,EACrB,KAAK,WAAWC,0DAAsB,OAAO,EAC9C;IACD,oBAAoB,EAClB,KAAK,WAAWC,uDAAmB,OAAO,EAC3C;IACD,qBAAqB,EACnB,KAAK,WAAWC,wDAAoB,OAAO,EAC5C;IACD,wBAAwB,EACtB,KAAK,WAAWC,2DAAuB,OAAO,EAC/C;IACD,iCAAiC,EAC/B,KAAK,WAAWC,oEAAgC,OAAO,EACxD;IACD,6BAA6B,EAC3B,KAAK,WAAWC,gEAA4B,OAAO,EACpD;IACD,yBAAyB,EACvB,KAAK,WAAWC,4DAAwB,OAAO,EAChD;IACF,CAAC;;EAGJ,qBAAqB,WAAW,UAAU;AACxC,qCAAoB,yBAAyB,WAAW,OAAO;IAC7D,kBAAkB,EAChB,KAAK,QAAQC,qDAAiB,IAAI,EACnC;IACD,sBAAsB,EACpB,KAAK,KAAK,aAAaC,yDAAqB,KAAK,SAAS,EAC3D;IACF,CAAC;;EAGJ,sBAAsB,QAAQ;AAC3B,GAAC,IAAY,uBAAuB,EAAE;;EAGzC,qBAAqB,UAAU;AAC7B,iCAAgB,yBAAyB,OAAO;IAC9C,mBAAmB,EACjB,KAAK,YAAYC,sDAAkB,OAAO,QAAQ,EACnD;IACD,qBAAqB,EACnB,KAAK,iBAAiBC,wDAAoB,OAAO,aAAa,EAC/D;IACF,CAAC;;EAEL;;;;;AAMH,MAAa,wBAAwB,gCAAgC"}

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

@@ -0,0 +1,13 @@
+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> {}
+declare function constructColumnGroupingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnGroupingFeatureConstructors<TFeatures, TData>>;
+/**
+ * The (Column) Grouping feature adds column grouping state and APIs to the table, row, column, and cell objects.
+ */
+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,13 @@
+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> {}
+declare function constructColumnGroupingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnGroupingFeatureConstructors<TFeatures, TData>>;
+/**
+ * The (Column) Grouping feature adds column grouping state and APIs to the table, row, column, and cell objects.
+ */
+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,70 @@
+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
+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 (Column) Grouping feature adds column grouping state and APIs to the table, row, column, and cell objects.
+*/
+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\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 (Column) Grouping feature adds column grouping state and APIs to the table, row, column, and cell objects.\n */\nexport const columnGroupingFeature = constructColumnGroupingFeature()\n"],"mappings":";;;;AAqDA,SAAgB,iCAGuD;AACrE,QAAO;EACL,kBAAkB,iBAAiB;AACjC,UAAO;IACL,UAAU,yBAAyB;IACnC,GAAG;IACJ;;EAGH,2BAA2B;AACzB,UAAO;IACL,iBAAiB,EAAE,eAAoB;;oCAAU,sEAAE,iGAAY,KAAI;;IACnE,eAAe;IAChB;;EAGH,yBAAyB,UAAU;AACjC,UAAO;IACL,kBAAkB,iBAAiB,YAAY,MAAM;IACrD,mBAAmB;IACpB;;EAGH,sBAAsB,WAAW,UAAU;AACzC,uBAAoB,yBAAyB,WAAW,OAAO;IAC7D,mBAAmB,EACjB,KAAK,SAAS,kBAAkB,KAAK,EACtC;IACD,uBAAuB,EACrB,KAAK,SAAS,sBAAsB,KAAK,EAC1C;IACD,sBAAsB,EACpB,KAAK,SAAS,qBAAqB,KAAK,EACzC;IACF,CAAC;;EAGJ,wBAAwB,WAAW,UAAU;AAC3C,uBAAoB,yBAAyB,WAAW,OAAO;IAC7D,uBAAuB,EACrB,KAAK,WAAW,sBAAsB,OAAO,EAC9C;IACD,oBAAoB,EAClB,KAAK,WAAW,mBAAmB,OAAO,EAC3C;IACD,qBAAqB,EACnB,KAAK,WAAW,oBAAoB,OAAO,EAC5C;IACD,wBAAwB,EACtB,KAAK,WAAW,uBAAuB,OAAO,EAC/C;IACD,iCAAiC,EAC/B,KAAK,WAAW,gCAAgC,OAAO,EACxD;IACD,6BAA6B,EAC3B,KAAK,WAAW,4BAA4B,OAAO,EACpD;IACD,yBAAyB,EACvB,KAAK,WAAW,wBAAwB,OAAO,EAChD;IACF,CAAC;;EAGJ,qBAAqB,WAAW,UAAU;AACxC,uBAAoB,yBAAyB,WAAW,OAAO;IAC7D,kBAAkB,EAChB,KAAK,QAAQ,iBAAiB,IAAI,EACnC;IACD,sBAAsB,EACpB,KAAK,KAAK,aAAa,qBAAqB,KAAK,SAAS,EAC3D;IACF,CAAC;;EAGJ,sBAAsB,QAAQ;AAC3B,GAAC,IAAY,uBAAuB,EAAE;;EAGzC,qBAAqB,UAAU;AAC7B,mBAAgB,yBAAyB,OAAO;IAC9C,mBAAmB,EACjB,KAAK,YAAY,kBAAkB,OAAO,QAAQ,EACnD;IACD,qBAAqB,EACnB,KAAK,iBAAiB,oBAAoB,OAAO,aAAa,EAC/D;IACF,CAAC;;EAEL;;;;;AAMH,MAAa,wBAAwB,gCAAgC"}

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

@@ -0,0 +1,157 @@
+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>;
+  /**
+   * Enables/disables grouping for this column.
+   */
+  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;
+  /**
+   * Returns whether or not the column can be grouped.
+   */
+  getCanGroup: () => boolean;
+  /**
+   * Returns the index of the column in the grouping state.
+   */
+  getGroupedIndex: () => number;
+  /**
+   * Returns whether or not the column is currently grouped.
+   */
+  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>;
+  /**
+   * Returns the grouping value for any row and column (including leaf rows).
+   */
+  getGroupingValue: (columnId: string) => unknown;
+  /**
+   * Returns whether or not the row is currently grouped.
+   */
+  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 {
+  /**
+   * Returns whether or not the cell is currently aggregated.
+   */
+  getIsAggregated: () => boolean;
+  /**
+   * Returns whether or not the cell is currently grouped.
+   */
+  getIsGrouped: () => boolean;
+  /**
+   * Returns whether or not the cell is currently a placeholder cell.
+   */
+  getIsPlaceholder: () => boolean;
+}
+interface ColumnDefaultOptions {
+  enableGrouping: boolean;
+  onGroupingChange: OnChangeFn<GroupingState>;
+}
+interface TableOptions_ColumnGrouping {
+  /**
+   * Enables/disables grouping for the 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;
+  /**
+   * If this function is provided, it will be called when the grouping state changes and you will be expected to manage the state yourself. You can pass the managed state back to the table via the `tableOptions.state.grouping` option.
+   */
+  onGroupingChange?: OnChangeFn<GroupingState>;
+}
+type GroupingColumnMode = false | 'reorder' | 'remove';
+interface Table_ColumnGrouping<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Resets the **grouping** state to `initialState.grouping`, or `true` can be passed to force a default blank state reset to `[]`.
+   */
+  resetGrouping: (defaultState?: boolean) => void;
+  /**
+   * Updates the grouping state of the table via an update function or value.
+   */
+  setGrouping: (updater: Updater<GroupingState>) => void;
+}
+interface Table_RowModels_Grouped<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Returns the row model for the table after grouping has been applied.
+   */
+  getGroupedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Returns the row model for the table before any grouping has been applied.
+   */
+  getPreGroupedRowModel: () => RowModel<TFeatures, TData>;
+}
+interface CreateRowModel_Grouped<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Returns the row model after grouping has taken place, but no further.
+   */
+  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

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

@@ -0,0 +1,157 @@
+import { CellData, OnChangeFn, RowData, Updater } from "../../types/type-utils.js";
+import { Row } from "../../types/Row.js";
+import { ColumnDefTemplate } from "../../types/ColumnDef.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+import { Table } from "../../types/Table.js";
+import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
+import { BuiltInAggregationFn } from "../../fns/aggregationFns.js";
+import { Cell } from "../../types/Cell.js";
+
+//#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>;
+  /**
+   * Enables/disables grouping for this column.
+   */
+  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;
+  /**
+   * Returns whether or not the column can be grouped.
+   */
+  getCanGroup: () => boolean;
+  /**
+   * Returns the index of the column in the grouping state.
+   */
+  getGroupedIndex: () => number;
+  /**
+   * Returns whether or not the column is currently grouped.
+   */
+  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>;
+  /**
+   * Returns the grouping value for any row and column (including leaf rows).
+   */
+  getGroupingValue: (columnId: string) => unknown;
+  /**
+   * Returns whether or not the row is currently grouped.
+   */
+  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 {
+  /**
+   * Returns whether or not the cell is currently aggregated.
+   */
+  getIsAggregated: () => boolean;
+  /**
+   * Returns whether or not the cell is currently grouped.
+   */
+  getIsGrouped: () => boolean;
+  /**
+   * Returns whether or not the cell is currently a placeholder cell.
+   */
+  getIsPlaceholder: () => boolean;
+}
+interface ColumnDefaultOptions {
+  enableGrouping: boolean;
+  onGroupingChange: OnChangeFn<GroupingState>;
+}
+interface TableOptions_ColumnGrouping {
+  /**
+   * Enables/disables grouping for the 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;
+  /**
+   * If this function is provided, it will be called when the grouping state changes and you will be expected to manage the state yourself. You can pass the managed state back to the table via the `tableOptions.state.grouping` option.
+   */
+  onGroupingChange?: OnChangeFn<GroupingState>;
+}
+type GroupingColumnMode = false | 'reorder' | 'remove';
+interface Table_ColumnGrouping<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Resets the **grouping** state to `initialState.grouping`, or `true` can be passed to force a default blank state reset to `[]`.
+   */
+  resetGrouping: (defaultState?: boolean) => void;
+  /**
+   * Updates the grouping state of the table via an update function or value.
+   */
+  setGrouping: (updater: Updater<GroupingState>) => void;
+}
+interface Table_RowModels_Grouped<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Returns the row model for the table after grouping has been applied.
+   */
+  getGroupedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Returns the row model for the table before any grouping has been applied.
+   */
+  getPreGroupedRowModel: () => RowModel<TFeatures, TData>;
+}
+interface CreateRowModel_Grouped<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Returns the row model after grouping has taken place, but no further.
+   */
+  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.ts.map