@tanstack/table-core 9.0.0-alpha.0 → 9.0.0-alpha.11

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

@@ -0,0 +1,10 @@
+import { RowData } from '../../types/type-utils.js';
+import { TableFeature, TableFeatures } from '../../types/TableFeatures.js';
+interface ColumnGroupingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {
+}
+export 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.
+ */
+export declare const columnGroupingFeature: TableFeature<ColumnGroupingFeatureConstructors<TableFeatures, RowData>>;
+export {};

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

@@ -0,0 +1,91 @@
+import { assignTableAPIs, assignPrototypeAPIs, makeStateUpdater } from "../../utils.js";
+import { table_resetGrouping, table_setGrouping, row_getGroupingValue, row_getIsGrouped, column_getAggregationFn, column_getAutoAggregationFn, column_getToggleGroupingHandler, column_getGroupedIndex, column_getIsGrouped, column_getCanGroup, column_toggleGrouping, cell_getIsAggregated, cell_getIsPlaceholder, cell_getIsGrouped, getDefaultGroupingState } from "./columnGroupingFeature.utils.js";
+function constructColumnGroupingFeature() {
+  return {
+    getInitialState: (initialState) => {
+      return {
+        grouping: getDefaultGroupingState(),
+        ...initialState
+      };
+    },
+    getDefaultColumnDef: () => {
+      return {
+        aggregatedCell: ({ getValue }) => getValue()?.toString?.() ?? 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)
+        }
+      });
+    }
+  };
+}
+const columnGroupingFeature = constructColumnGroupingFeature();
+export {
+  columnGroupingFeature,
+  constructColumnGroupingFeature
+};
+//# sourceMappingURL=columnGroupingFeature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"columnGroupingFeature.js","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\ninterface 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"],"names":[],"mappings":";;AAqDO,SAAS,iCAGuD;AACrE,SAAO;AAAA,IACL,iBAAiB,CAAC,iBAAiB;AACjC,aAAO;AAAA,QACL,UAAU,wBAAA;AAAA,QACV,GAAG;AAAA,MAAA;AAAA,IAEP;AAAA,IAEA,qBAAqB,MAAM;AACzB,aAAO;AAAA,QACL,gBAAgB,CAAC,EAAE,SAAA,MAAoB,SAAA,GAAY,gBAAgB;AAAA,QACnE,eAAe;AAAA,MAAA;AAAA,IAEnB;AAAA,IAEA,wBAAwB,CAAC,UAAU;AACjC,aAAO;AAAA,QACL,kBAAkB,iBAAiB,YAAY,KAAK;AAAA,QACpD,mBAAmB;AAAA,MAAA;AAAA,IAEvB;AAAA,IAEA,qBAAqB,CAAC,WAAW,UAAU;AACzC,0BAAoB,yBAAyB,WAAW,OAAO;AAAA,QAC7D,mBAAmB;AAAA,UACjB,IAAI,CAAC,SAAS,kBAAkB,IAAI;AAAA,QAAA;AAAA,QAEtC,uBAAuB;AAAA,UACrB,IAAI,CAAC,SAAS,sBAAsB,IAAI;AAAA,QAAA;AAAA,QAE1C,sBAAsB;AAAA,UACpB,IAAI,CAAC,SAAS,qBAAqB,IAAI;AAAA,QAAA;AAAA,MACzC,CACD;AAAA,IACH;AAAA,IAEA,uBAAuB,CAAC,WAAW,UAAU;AAC3C,0BAAoB,yBAAyB,WAAW,OAAO;AAAA,QAC7D,uBAAuB;AAAA,UACrB,IAAI,CAAC,WAAW,sBAAsB,MAAM;AAAA,QAAA;AAAA,QAE9C,oBAAoB;AAAA,UAClB,IAAI,CAAC,WAAW,mBAAmB,MAAM;AAAA,QAAA;AAAA,QAE3C,qBAAqB;AAAA,UACnB,IAAI,CAAC,WAAW,oBAAoB,MAAM;AAAA,QAAA;AAAA,QAE5C,wBAAwB;AAAA,UACtB,IAAI,CAAC,WAAW,uBAAuB,MAAM;AAAA,QAAA;AAAA,QAE/C,iCAAiC;AAAA,UAC/B,IAAI,CAAC,WAAW,gCAAgC,MAAM;AAAA,QAAA;AAAA,QAExD,6BAA6B;AAAA,UAC3B,IAAI,CAAC,WAAW,4BAA4B,MAAM;AAAA,QAAA;AAAA,QAEpD,yBAAyB;AAAA,UACvB,IAAI,CAAC,WAAW,wBAAwB,MAAM;AAAA,QAAA;AAAA,MAChD,CACD;AAAA,IACH;AAAA,IAEA,oBAAoB,CAAC,WAAW,UAAU;AACxC,0BAAoB,yBAAyB,WAAW,OAAO;AAAA,QAC7D,kBAAkB;AAAA,UAChB,IAAI,CAAC,QAAQ,iBAAiB,GAAG;AAAA,QAAA;AAAA,QAEnC,sBAAsB;AAAA,UACpB,IAAI,CAAC,KAAK,aAAa,qBAAqB,KAAK,QAAQ;AAAA,QAAA;AAAA,MAC3D,CACD;AAAA,IACH;AAAA,IAEA,qBAAqB,CAAC,QAAQ;AAC1B,UAAY,uBAAuB,CAAA;AAAA,IACvC;AAAA,IAEA,oBAAoB,CAAC,UAAU;AAC7B,sBAAgB,yBAAyB,OAAO;AAAA,QAC9C,mBAAmB;AAAA,UACjB,IAAI,CAAC,YAAY,kBAAkB,OAAO,OAAO;AAAA,QAAA;AAAA,QAEnD,qBAAqB;AAAA,UACnB,IAAI,CAAC,iBAAiB,oBAAoB,OAAO,YAAY;AAAA,QAAA;AAAA,MAC/D,CACD;AAAA,IACH;AAAA,EAAA;AAEJ;AAKO,MAAM,wBAAwB,+BAAA;"}

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

@@ -0,0 +1,153 @@
+import { RowModel } from '../../core/row-models/coreRowModelsFeature.types';
+import { Table } from '../../types/Table.js';
+import { BuiltInAggregationFn } from '../../fns/aggregationFns.js';
+import { CellData, OnChangeFn, RowData, Updater } from '../../types/type-utils.js';
+import { TableFeatures } from '../../types/TableFeatures.js';
+import { Row } from '../../types/Row.js';
+import { Cell } from '../../types/Cell.js';
+import { ColumnDefTemplate } from '../../types/ColumnDef.js';
+export type GroupingState = Array<string>;
+export interface TableState_ColumnGrouping {
+    grouping: GroupingState;
+}
+export interface RowModelFns_ColumnGrouping<TFeatures extends TableFeatures, TData extends RowData> {
+    aggregationFns: Record<keyof AggregationFns, AggregationFn<TFeatures, TData>>;
+}
+export interface AggregationFns {
+}
+export type AggregationFn<TFeatures extends TableFeatures, TData extends RowData> = (columnId: string, leafRows: Array<Row<TFeatures, TData>>, childRows: Array<Row<TFeatures, TData>>) => any;
+export type CustomAggregationFns<TFeatures extends TableFeatures, TData extends RowData> = Record<string, AggregationFn<TFeatures, TData>>;
+export type AggregationFnOption<TFeatures extends TableFeatures, TData extends RowData> = 'auto' | keyof AggregationFns | BuiltInAggregationFn | AggregationFn<TFeatures, TData>;
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export interface ColumnDefaultOptions {
+    enableGrouping: boolean;
+    onGroupingChange: OnChangeFn<GroupingState>;
+}
+export 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>;
+}
+export type GroupingColumnMode = false | 'reorder' | 'remove';
+export 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;
+}
+export 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>;
+}
+export 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>;
+}
+export interface CachedRowModel_Grouped<TFeatures extends TableFeatures, TData extends RowData> {
+    groupedRowModel: () => RowModel<TFeatures, TData>;
+}

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

@@ -0,0 +1,22 @@
+import { Column_Internal } from '../../types/Column.js';
+import { CellData, RowData, Updater } from '../../types/type-utils.js';
+import { TableFeatures } from '../../types/TableFeatures.js';
+import { Table_Internal } from '../../types/Table.js';
+import { Row } from '../../types/Row.js';
+import { Cell } from '../../types/Cell.js';
+import { AggregationFn, GroupingState, Row_ColumnGrouping } from './columnGroupingFeature.types';
+export declare function getDefaultGroupingState(): GroupingState;
+export declare function column_toggleGrouping<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): void;
+export declare function column_getCanGroup<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
+export declare function column_getIsGrouped<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
+export declare function column_getGroupedIndex<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): number;
+export declare function column_getToggleGroupingHandler<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): () => void;
+export declare function column_getAutoAggregationFn<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): AggregationFn<TFeatures, TData> | undefined;
+export declare function column_getAggregationFn<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): AggregationFn<TFeatures, TData> | undefined;
+export declare function table_setGrouping<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<GroupingState>): void;
+export declare function table_resetGrouping<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
+export declare function row_getIsGrouped<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData> & Partial<Row_ColumnGrouping>): boolean;
+export declare function row_getGroupingValue<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData> & Partial<Row_ColumnGrouping>, columnId: string): any;
+export declare function cell_getIsGrouped<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(cell: Cell<TFeatures, TData, TValue>): boolean;
+export declare function cell_getIsPlaceholder<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(cell: Cell<TFeatures, TData, TValue>): boolean;
+export declare function cell_getIsAggregated<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(cell: Cell<TFeatures, TData, TValue>): boolean;

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

@@ -0,0 +1,99 @@
+import { isFunction } from "../../utils.js";
+import { table_getColumn } from "../../core/columns/coreColumnsFeature.utils.js";
+function getDefaultGroupingState() {
+  return structuredClone([]);
+}
+function column_toggleGrouping(column) {
+  table_setGrouping(column.table, (old) => {
+    if (old.includes(column.id)) {
+      return old.filter((d) => d !== column.id);
+    }
+    return [...old, column.id];
+  });
+}
+function column_getCanGroup(column) {
+  return (column.columnDef.enableGrouping ?? true) && (column.table.options.enableGrouping ?? true) && (!!column.accessorFn || !!column.columnDef.getGroupingValue);
+}
+function column_getIsGrouped(column) {
+  return !!column.table.store.state.grouping?.includes(column.id);
+}
+function column_getGroupedIndex(column) {
+  return column.table.store.state.grouping?.indexOf(column.id) ?? -1;
+}
+function column_getToggleGroupingHandler(column) {
+  const canGroup = column_getCanGroup(column);
+  return () => {
+    if (!canGroup) return;
+    column_toggleGrouping(column);
+  };
+}
+function column_getAutoAggregationFn(column) {
+  const aggregationFns = column.table._rowModelFns.aggregationFns;
+  const firstRow = column.table.getCoreRowModel().flatRows[0];
+  const value = firstRow?.getValue(column.id);
+  if (typeof value === "number") {
+    return aggregationFns?.sum;
+  }
+  if (Object.prototype.toString.call(value) === "[object Date]") {
+    return aggregationFns?.extent;
+  }
+}
+function column_getAggregationFn(column) {
+  const aggregationFns = column.table._rowModelFns.aggregationFns;
+  return isFunction(column.columnDef.aggregationFn) ? column.columnDef.aggregationFn : column.columnDef.aggregationFn === "auto" ? column_getAutoAggregationFn(column) : aggregationFns?.[column.columnDef.aggregationFn];
+}
+function table_setGrouping(table, updater) {
+  table.options.onGroupingChange?.(updater);
+}
+function table_resetGrouping(table, defaultState) {
+  table_setGrouping(
+    table,
+    defaultState ? [] : table.initialState.grouping ?? []
+  );
+}
+function row_getIsGrouped(row) {
+  return !!row.groupingColumnId;
+}
+function row_getGroupingValue(row, columnId) {
+  if (row._groupingValuesCache?.hasOwnProperty(columnId)) {
+    return row._groupingValuesCache[columnId];
+  }
+  const column = table_getColumn(row.table, columnId);
+  if (!column.columnDef.getGroupingValue) {
+    return row.getValue(columnId);
+  }
+  if (row._groupingValuesCache) {
+    row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(
+      row.original
+    );
+  }
+  return row._groupingValuesCache?.[columnId];
+}
+function cell_getIsGrouped(cell) {
+  const row = cell.row;
+  return column_getIsGrouped(cell.column) && cell.column.id === row.groupingColumnId;
+}
+function cell_getIsPlaceholder(cell) {
+  return !cell_getIsGrouped(cell) && column_getIsGrouped(cell.column);
+}
+function cell_getIsAggregated(cell) {
+  return !cell_getIsGrouped(cell) && !cell_getIsPlaceholder(cell) && !!cell.row.subRows.length;
+}
+export {
+  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
+};
+//# sourceMappingURL=columnGroupingFeature.utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"columnGroupingFeature.utils.js","sources":["../../../../src/features/column-grouping/columnGroupingFeature.utils.ts"],"sourcesContent":["import { isFunction } from '../../utils'\nimport { table_getColumn } from '../../core/columns/coreColumnsFeature.utils'\nimport type { Column_Internal } from '../../types/Column'\nimport type { CellData, RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Row } from '../../types/Row'\nimport type { Cell } from '../../types/Cell'\nimport type {\n  AggregationFn,\n  GroupingState,\n  Row_ColumnGrouping,\n} from './columnGroupingFeature.types'\n\nexport function getDefaultGroupingState(): GroupingState {\n  return structuredClone([])\n}\n\nexport function column_toggleGrouping<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  table_setGrouping(column.table, (old) => {\n    // Find any existing grouping for this column\n    if (old.includes(column.id)) {\n      return old.filter((d) => d !== column.id)\n    }\n\n    return [...old, column.id]\n  })\n}\n\nexport function column_getCanGroup<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (\n    (column.columnDef.enableGrouping ?? true) &&\n    (column.table.options.enableGrouping ?? true) &&\n    (!!column.accessorFn || !!column.columnDef.getGroupingValue)\n  )\n}\n\nexport function column_getIsGrouped<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): boolean {\n  return !!column.table.store.state.grouping?.includes(column.id)\n}\n\nexport function column_getGroupedIndex<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): number {\n  return column.table.store.state.grouping?.indexOf(column.id) ?? -1\n}\n\nexport function column_getToggleGroupingHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  const canGroup = column_getCanGroup(column)\n\n  return () => {\n    if (!canGroup) return\n    column_toggleGrouping(column)\n  }\n}\n\nexport function column_getAutoAggregationFn<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  const aggregationFns = column.table._rowModelFns.aggregationFns as\n    | Record<string, AggregationFn<TFeatures, TData>>\n    | undefined\n\n  const firstRow = column.table.getCoreRowModel().flatRows[0]\n\n  const value = firstRow?.getValue(column.id)\n\n  if (typeof value === 'number') {\n    return aggregationFns?.sum\n  }\n\n  if (Object.prototype.toString.call(value) === '[object Date]') {\n    return aggregationFns?.extent\n  }\n}\n\nexport function column_getAggregationFn<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  const aggregationFns = column.table._rowModelFns.aggregationFns as\n    | Record<string, AggregationFn<TFeatures, TData>>\n    | undefined\n\n  return isFunction(column.columnDef.aggregationFn)\n    ? column.columnDef.aggregationFn\n    : column.columnDef.aggregationFn === 'auto'\n      ? column_getAutoAggregationFn(column)\n      : aggregationFns?.[column.columnDef.aggregationFn as string]\n}\n\nexport function table_setGrouping<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: Updater<GroupingState>) {\n  table.options.onGroupingChange?.(updater)\n}\n\nexport function table_resetGrouping<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setGrouping(\n    table,\n    defaultState ? [] : (table.initialState.grouping ?? []),\n  )\n}\n\nexport function row_getIsGrouped<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData> & Partial<Row_ColumnGrouping>) {\n  return !!row.groupingColumnId\n}\n\nexport function row_getGroupingValue<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData> & Partial<Row_ColumnGrouping>, columnId: string) {\n  if (row._groupingValuesCache?.hasOwnProperty(columnId)) {\n    return row._groupingValuesCache[columnId]\n  }\n\n  const column = table_getColumn(row.table, columnId) as Column_Internal<\n    TFeatures,\n    TData\n  >\n\n  if (!column.columnDef.getGroupingValue) {\n    return row.getValue(columnId)\n  }\n\n  if (row._groupingValuesCache) {\n    row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(\n      row.original,\n    )\n  }\n\n  return row._groupingValuesCache?.[columnId]\n}\n\nexport function cell_getIsGrouped<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(cell: Cell<TFeatures, TData, TValue>) {\n  const row = cell.row as Row<TFeatures, TData> & Partial<Row_ColumnGrouping>\n  return (\n    column_getIsGrouped(cell.column) && cell.column.id === row.groupingColumnId\n  )\n}\n\nexport function cell_getIsPlaceholder<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(cell: Cell<TFeatures, TData, TValue>) {\n  return !cell_getIsGrouped(cell) && column_getIsGrouped(cell.column)\n}\n\nexport function cell_getIsAggregated<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(cell: Cell<TFeatures, TData, TValue>) {\n  return (\n    !cell_getIsGrouped(cell) &&\n    !cell_getIsPlaceholder(cell) &&\n    !!cell.row.subRows.length\n  )\n}\n"],"names":[],"mappings":";;AAcO,SAAS,0BAAyC;AACvD,SAAO,gBAAgB,CAAA,CAAE;AAC3B;AAEO,SAAS,sBAId,QAAmD;AACnD,oBAAkB,OAAO,OAAO,CAAC,QAAQ;AAEvC,QAAI,IAAI,SAAS,OAAO,EAAE,GAAG;AAC3B,aAAO,IAAI,OAAO,CAAC,MAAM,MAAM,OAAO,EAAE;AAAA,IAC1C;AAEA,WAAO,CAAC,GAAG,KAAK,OAAO,EAAE;AAAA,EAC3B,CAAC;AACH;AAEO,SAAS,mBAId,QAAmD;AACnD,UACG,OAAO,UAAU,kBAAkB,UACnC,OAAO,MAAM,QAAQ,kBAAkB,UACvC,CAAC,CAAC,OAAO,cAAc,CAAC,CAAC,OAAO,UAAU;AAE/C;AAEO,SAAS,oBAId,QAA4D;AAC5D,SAAO,CAAC,CAAC,OAAO,MAAM,MAAM,MAAM,UAAU,SAAS,OAAO,EAAE;AAChE;AAEO,SAAS,uBAId,QAA2D;AAC3D,SAAO,OAAO,MAAM,MAAM,MAAM,UAAU,QAAQ,OAAO,EAAE,KAAK;AAClE;AAEO,SAAS,gCAId,QAAmD;AACnD,QAAM,WAAW,mBAAmB,MAAM;AAE1C,SAAO,MAAM;AACX,QAAI,CAAC,SAAU;AACf,0BAAsB,MAAM;AAAA,EAC9B;AACF;AAEO,SAAS,4BAId,QAAmD;AACnD,QAAM,iBAAiB,OAAO,MAAM,aAAa;AAIjD,QAAM,WAAW,OAAO,MAAM,gBAAA,EAAkB,SAAS,CAAC;AAE1D,QAAM,QAAQ,UAAU,SAAS,OAAO,EAAE;AAE1C,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,gBAAgB;AAAA,EACzB;AAEA,MAAI,OAAO,UAAU,SAAS,KAAK,KAAK,MAAM,iBAAiB;AAC7D,WAAO,gBAAgB;AAAA,EACzB;AACF;AAEO,SAAS,wBAId,QAAmD;AACnD,QAAM,iBAAiB,OAAO,MAAM,aAAa;AAIjD,SAAO,WAAW,OAAO,UAAU,aAAa,IAC5C,OAAO,UAAU,gBACjB,OAAO,UAAU,kBAAkB,SACjC,4BAA4B,MAAM,IAClC,iBAAiB,OAAO,UAAU,aAAuB;AACjE;AAEO,SAAS,kBAGd,OAAyC,SAAiC;AAC1E,QAAM,QAAQ,mBAAmB,OAAO;AAC1C;AAEO,SAAS,oBAGd,OAAyC,cAAwB;AACjE;AAAA,IACE;AAAA,IACA,eAAe,CAAA,IAAM,MAAM,aAAa,YAAY,CAAA;AAAA,EAAC;AAEzD;AAEO,SAAS,iBAGd,KAA0D;AAC1D,SAAO,CAAC,CAAC,IAAI;AACf;AAEO,SAAS,qBAGd,KAA0D,UAAkB;AAC5E,MAAI,IAAI,sBAAsB,eAAe,QAAQ,GAAG;AACtD,WAAO,IAAI,qBAAqB,QAAQ;AAAA,EAC1C;AAEA,QAAM,SAAS,gBAAgB,IAAI,OAAO,QAAQ;AAKlD,MAAI,CAAC,OAAO,UAAU,kBAAkB;AACtC,WAAO,IAAI,SAAS,QAAQ;AAAA,EAC9B;AAEA,MAAI,IAAI,sBAAsB;AAC5B,QAAI,qBAAqB,QAAQ,IAAI,OAAO,UAAU;AAAA,MACpD,IAAI;AAAA,IAAA;AAAA,EAER;AAEA,SAAO,IAAI,uBAAuB,QAAQ;AAC5C;AAEO,SAAS,kBAId,MAAsC;AACtC,QAAM,MAAM,KAAK;AACjB,SACE,oBAAoB,KAAK,MAAM,KAAK,KAAK,OAAO,OAAO,IAAI;AAE/D;AAEO,SAAS,sBAId,MAAsC;AACtC,SAAO,CAAC,kBAAkB,IAAI,KAAK,oBAAoB,KAAK,MAAM;AACpE;AAEO,SAAS,qBAId,MAAsC;AACtC,SACE,CAAC,kBAAkB,IAAI,KACvB,CAAC,sBAAsB,IAAI,KAC3B,CAAC,CAAC,KAAK,IAAI,QAAQ;AAEvB;"}

package/dist/esm/features/column-grouping/createGroupedRowModel.d.ts

@@ -0,0 +1,6 @@
+import { AggregationFn, AggregationFns } from './columnGroupingFeature.types';
+import { TableFeatures } from '../../types/TableFeatures.js';
+import { RowModel } from '../../core/row-models/coreRowModelsFeature.types';
+import { Table } from '../../types/Table.js';
+import { RowData } from '../../types/type-utils.js';
+export declare function createGroupedRowModel<TFeatures extends TableFeatures, TData extends RowData = any>(aggregationFns: Record<keyof AggregationFns, AggregationFn<TFeatures, TData>>): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;

package/dist/esm/features/column-grouping/createGroupedRowModel.js

@@ -0,0 +1,144 @@
+import { tableMemo, flattenBy } from "../../utils.js";
+import { constructRow } from "../../core/rows/constructRow.js";
+import { table_getColumn } from "../../core/columns/coreColumnsFeature.utils.js";
+import { table_autoResetExpanded } from "../row-expanding/rowExpandingFeature.utils.js";
+import { table_autoResetPageIndex } from "../row-pagination/rowPaginationFeature.utils.js";
+import { column_getAggregationFn, row_getGroupingValue } from "./columnGroupingFeature.utils.js";
+function createGroupedRowModel(aggregationFns) {
+  return (_table) => {
+    const table = _table;
+    if (!table._rowModelFns.aggregationFns)
+      table._rowModelFns.aggregationFns = aggregationFns;
+    return tableMemo({
+      feature: "columnGroupingFeature",
+      table,
+      fnName: "table.getGroupedRowModel",
+      memoDeps: () => [
+        table.store.state.grouping,
+        table.getPreGroupedRowModel()
+      ],
+      fn: () => _createGroupedRowModel(table),
+      onAfterUpdate: () => {
+        table_autoResetExpanded(table);
+        table_autoResetPageIndex(table);
+      }
+    });
+  };
+}
+function _createGroupedRowModel(table) {
+  const rowModel = table.getPreGroupedRowModel();
+  const grouping = table.store.state.grouping;
+  if (!rowModel.rows.length || !grouping?.length) {
+    rowModel.rows.forEach((row) => {
+      row.depth = 0;
+      row.parentId = void 0;
+    });
+    return rowModel;
+  }
+  const existingGrouping = grouping.filter(
+    (columnId) => table_getColumn(table, columnId)
+  );
+  const groupedFlatRows = [];
+  const groupedRowsById = {};
+  const groupUpRecursively = (rows, depth = 0, parentId) => {
+    if (depth >= existingGrouping.length) {
+      return rows.map((row) => {
+        row.depth = depth;
+        groupedFlatRows.push(row);
+        groupedRowsById[row.id] = row;
+        if (row.subRows.length) {
+          row.subRows = groupUpRecursively(row.subRows, depth + 1, row.id);
+        }
+        return row;
+      });
+    }
+    const columnId = existingGrouping[depth];
+    const rowGroupsMap = groupBy(rows, columnId);
+    const aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map(
+      ([groupingValue, groupedRows2], index) => {
+        let id = `${columnId}:${groupingValue}`;
+        id = parentId ? `${parentId}>${id}` : id;
+        const subRows = groupUpRecursively(groupedRows2, depth + 1, id);
+        subRows.forEach((subRow) => {
+          subRow.parentId = id;
+        });
+        const leafRows = depth ? flattenBy(groupedRows2, (row2) => row2.subRows) : groupedRows2;
+        const row = constructRow(
+          table,
+          id,
+          leafRows[0].original,
+          index,
+          depth,
+          void 0,
+          parentId
+        );
+        Object.assign(row, {
+          groupingColumnId: columnId,
+          groupingValue,
+          subRows,
+          leafRows,
+          getValue: (colId) => {
+            if (existingGrouping.includes(colId)) {
+              if (row._valuesCache.hasOwnProperty(colId)) {
+                return row._valuesCache[colId];
+              }
+              if (groupedRows2[0]) {
+                row._valuesCache[colId] = groupedRows2[0].getValue(colId) ?? void 0;
+              }
+              return row._valuesCache[colId];
+            }
+            if (row._groupingValuesCache?.hasOwnProperty(colId)) {
+              return row._groupingValuesCache[colId];
+            }
+            const column = table.getColumn(colId);
+            const aggregateFn = column_getAggregationFn(
+              column
+            );
+            if (!row._groupingValuesCache) row._groupingValuesCache = {};
+            if (aggregateFn) {
+              row._groupingValuesCache[colId] = aggregateFn(
+                colId,
+                leafRows,
+                groupedRows2
+              );
+              return row._groupingValuesCache[colId];
+            }
+          }
+        });
+        subRows.forEach((subRow) => {
+          groupedFlatRows.push(subRow);
+          groupedRowsById[subRow.id] = subRow;
+        });
+        return row;
+      }
+    );
+    return aggregatedGroupedRows;
+  };
+  const groupedRows = groupUpRecursively(rowModel.rows, 0);
+  groupedRows.forEach((subRow) => {
+    groupedFlatRows.push(subRow);
+    groupedRowsById[subRow.id] = subRow;
+  });
+  return {
+    rows: groupedRows,
+    flatRows: groupedFlatRows,
+    rowsById: groupedRowsById
+  };
+}
+function groupBy(rows, columnId) {
+  const groupMap = /* @__PURE__ */ new Map();
+  return rows.reduce((map, row) => {
+    const resKey = `${row_getGroupingValue(row, columnId)}`;
+    const previous = map.get(resKey);
+    if (!previous) {
+      map.set(resKey, [row]);
+    } else {
+      previous.push(row);
+    }
+    return map;
+  }, groupMap);
+}
+export {
+  createGroupedRowModel
+};
+//# sourceMappingURL=createGroupedRowModel.js.map

package/dist/esm/features/column-grouping/createGroupedRowModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createGroupedRowModel.js","sources":["../../../../src/features/column-grouping/createGroupedRowModel.ts"],"sourcesContent":["import { flattenBy, tableMemo } from '../../utils'\nimport { constructRow } from '../../core/rows/constructRow'\nimport { table_getColumn } from '../../core/columns/coreColumnsFeature.utils'\nimport { table_autoResetExpanded } from '../row-expanding/rowExpandingFeature.utils'\nimport { table_autoResetPageIndex } from '../row-pagination/rowPaginationFeature.utils'\nimport {\n  column_getAggregationFn,\n  row_getGroupingValue,\n} from './columnGroupingFeature.utils'\nimport type { Column } from '../../types/Column'\nimport type {\n  AggregationFn,\n  AggregationFns,\n  Row_ColumnGrouping,\n} from './columnGroupingFeature.types'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { Row } from '../../types/Row'\nimport type { RowData } from '../../types/type-utils'\n\nexport function createGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  aggregationFns: Record<keyof AggregationFns, AggregationFn<TFeatures, TData>>,\n): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {\n  return (_table) => {\n    const table = _table as Table_Internal<TFeatures, TData>\n    if (!table._rowModelFns.aggregationFns)\n      table._rowModelFns.aggregationFns = aggregationFns\n    return tableMemo({\n      feature: 'columnGroupingFeature',\n      table,\n      fnName: 'table.getGroupedRowModel',\n      memoDeps: () => [\n        table.store.state.grouping,\n        table.getPreGroupedRowModel(),\n      ],\n      fn: () => _createGroupedRowModel(table),\n      onAfterUpdate: () => {\n        table_autoResetExpanded(table)\n        table_autoResetPageIndex(table)\n      },\n    })\n  }\n}\n\nfunction _createGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  const rowModel = table.getPreGroupedRowModel()\n  const grouping = table.store.state.grouping\n\n  if (!rowModel.rows.length || !grouping?.length) {\n    rowModel.rows.forEach((row) => {\n      row.depth = 0\n      row.parentId = undefined\n    })\n    return rowModel\n  }\n\n  // Filter the grouping list down to columns that exist\n  const existingGrouping = grouping.filter((columnId) =>\n    table_getColumn(table, columnId),\n  )\n\n  const groupedFlatRows: Array<Row<TFeatures, TData>> &\n    Partial<Row_ColumnGrouping> = []\n  const groupedRowsById: Record<string, Row<TFeatures, TData>> = {}\n\n  // Recursively group the data\n  const groupUpRecursively = (\n    rows: Array<Row<TFeatures, TData>>,\n    depth = 0,\n    parentId?: string,\n  ) => {\n    // Grouping depth has been been met\n    // Stop grouping and simply rewrite thd depth and row relationships\n    if (depth >= existingGrouping.length) {\n      return rows.map((row) => {\n        row.depth = depth\n\n        groupedFlatRows.push(row)\n        groupedRowsById[row.id] = row\n\n        if (row.subRows.length) {\n          row.subRows = groupUpRecursively(row.subRows, depth + 1, row.id)\n        }\n\n        return row\n      })\n    }\n\n    const columnId = existingGrouping[depth] as string\n\n    // Group the rows together for this level\n    const rowGroupsMap = groupBy(rows, columnId)\n\n    // Perform aggregations for each group\n    const aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map(\n      ([groupingValue, groupedRows], index) => {\n        let id = `${columnId}:${groupingValue}`\n        id = parentId ? `${parentId}>${id}` : id\n\n        // First, Recurse to group sub rows before aggregation\n        const subRows = groupUpRecursively(groupedRows, depth + 1, id)\n\n        subRows.forEach((subRow) => {\n          subRow.parentId = id\n        })\n\n        // Flatten the leaf rows of the rows in this group\n        const leafRows = depth\n          ? flattenBy(groupedRows, (row) => row.subRows)\n          : groupedRows\n\n        const row = constructRow(\n          table,\n          id,\n          leafRows[0]!.original,\n          index,\n          depth,\n          undefined,\n          parentId,\n        ) as Row<TFeatures, TData> & Partial<Row_ColumnGrouping>\n\n        Object.assign(row, {\n          groupingColumnId: columnId,\n          groupingValue,\n          subRows,\n          leafRows,\n          getValue: (colId: string) => {\n            // Don't aggregate columns that are in the grouping\n            if (existingGrouping.includes(colId)) {\n              if (row._valuesCache.hasOwnProperty(colId)) {\n                return row._valuesCache[colId]\n              }\n\n              if (groupedRows[0]) {\n                row._valuesCache[colId] =\n                  groupedRows[0].getValue(colId) ?? undefined\n              }\n\n              return row._valuesCache[colId]\n            }\n\n            if (row._groupingValuesCache?.hasOwnProperty(colId)) {\n              return row._groupingValuesCache[colId]\n            }\n\n            // Aggregate the values\n            const column = table.getColumn(colId)\n            const aggregateFn = column_getAggregationFn(\n              column as Column<TFeatures, TData, unknown>,\n            )\n\n            if (!row._groupingValuesCache) row._groupingValuesCache = {}\n\n            if (aggregateFn) {\n              row._groupingValuesCache[colId] = aggregateFn(\n                colId,\n                leafRows,\n                groupedRows,\n              )\n\n              return row._groupingValuesCache[colId]\n            }\n          },\n        })\n\n        subRows.forEach((subRow) => {\n          groupedFlatRows.push(subRow)\n          groupedRowsById[subRow.id] = subRow\n        })\n\n        return row\n      },\n    )\n\n    return aggregatedGroupedRows\n  }\n\n  const groupedRows = groupUpRecursively(rowModel.rows, 0)\n\n  groupedRows.forEach((subRow) => {\n    groupedFlatRows.push(subRow)\n    groupedRowsById[subRow.id] = subRow\n  })\n\n  return {\n    rows: groupedRows,\n    flatRows: groupedFlatRows,\n    rowsById: groupedRowsById,\n  }\n}\n\nfunction groupBy<TFeatures extends TableFeatures, TData extends RowData = any>(\n  rows: Array<Row<TFeatures, TData>>,\n  columnId: string,\n) {\n  const groupMap = new Map<any, Array<Row<TFeatures, TData>>>()\n\n  return rows.reduce((map, row) => {\n    const resKey = `${row_getGroupingValue(row, columnId)}`\n    const previous = map.get(resKey)\n    if (!previous) {\n      map.set(resKey, [row])\n    } else {\n      previous.push(row)\n    }\n    return map\n  }, groupMap)\n}\n"],"names":["groupedRows","row"],"mappings":"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"}

package/dist/esm/features/column-ordering/columnOrderingFeature.d.ts

@@ -0,0 +1,10 @@
+import { RowData } from '../../types/type-utils.js';
+import { TableFeature, TableFeatures } from '../../types/TableFeatures.js';
+interface ColumnOrderingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {
+}
+export declare function constructColumnOrderingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnOrderingFeatureConstructors<TFeatures, TData>>;
+/**
+ * The Column Ordering feature adds column ordering state and APIs to the table and column objects.
+ */
+export declare const columnOrderingFeature: TableFeature<ColumnOrderingFeatureConstructors<TableFeatures, RowData>>;
+export {};