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

package/dist/core/row-models/coreRowModelsFeature.types.d.cts

@@ -1,6 +1,6 @@
 import { RowData } from "../../types/type-utils.cjs";
-import { Table_RowModels_Sorted } from "../../features/row-sorting/rowSortingFeature.types.cjs";
 import { Table_RowModels_Grouped } from "../../features/column-grouping/columnGroupingFeature.types.cjs";
+import { Table_RowModels_Sorted } from "../../features/row-sorting/rowSortingFeature.types.cjs";
 import { Table_RowModels_Expanded } from "../../features/row-expanding/rowExpandingFeature.types.cjs";
 import { Row } from "../../types/Row.cjs";
 import { Table_RowModels_Filtered } from "../../features/column-filtering/columnFilteringFeature.types.cjs";

package/dist/core/row-models/coreRowModelsFeature.types.d.ts

@@ -1,6 +1,6 @@
 import { RowData } from "../../types/type-utils.js";
-import { Table_RowModels_Sorted } from "../../features/row-sorting/rowSortingFeature.types.js";
 import { Table_RowModels_Grouped } from "../../features/column-grouping/columnGroupingFeature.types.js";
+import { Table_RowModels_Sorted } from "../../features/row-sorting/rowSortingFeature.types.js";
 import { Table_RowModels_Expanded } from "../../features/row-expanding/rowExpandingFeature.types.js";
 import { Row } from "../../types/Row.js";
 import { Table_RowModels_Filtered } from "../../features/column-filtering/columnFilteringFeature.types.js";

package/dist/core/row-models/coreRowModelsFeature.utils.cjs

@@ -61,7 +61,7 @@ function table_getPreGroupedRowModel(table) {
 	return table.getFilteredRowModel();
 }
 /**
-* Resolves the row model after grouping has produced grouped and aggregated rows.
+* Resolves the row model after grouping has produced grouped rows.
 *
 * When `manualGrouping` is enabled, or no grouped row-model factory was
 * registered, this returns the pre-grouped row model unchanged.

package/dist/core/row-models/coreRowModelsFeature.utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"coreRowModelsFeature.utils.cjs","names":["createCoreRowModel"],"sources":["../../../src/core/row-models/coreRowModelsFeature.utils.ts"],"sourcesContent":["import { createCoreRowModel } from './createCoreRowModel'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\nimport type { RowModel } from './coreRowModelsFeature.types'\n\n/**\n * Resolves the table's unmodified core row model.\n *\n * The factory is created once per table, either from the `coreRowModel` slot on the `features` option\n * or the built-in `createCoreRowModel()`, then reused for later calls.\n *\n * @example\n * ```ts\n * const coreRows = table_getCoreRowModel(table)\n * ```\n */\nexport function table_getCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.coreRowModel) {\n    table._rowModels.coreRowModel =\n      table.options.features.coreRowModel?.(table) ??\n      createCoreRowModel<TFeatures, TData>()(table)\n  }\n\n  return table._rowModels.coreRowModel()\n}\n\n/**\n * Reads the row model immediately before column/global filtering.\n *\n * Filtering is the first derived row-model stage, so this currently aliases\n * `table.getCoreRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeFiltering = table_getPreFilteredRowModel(table)\n * ```\n */\nexport function table_getPreFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getCoreRowModel()\n}\n\n/**\n * Resolves the row model after column and global filtering.\n *\n * When `manualFiltering` is enabled, or no filtered row-model factory was\n * registered, this returns the pre-filtered row model because filtering is\n * expected to happen outside the table.\n *\n * @example\n * ```ts\n * const filteredRows = table_getFilteredRowModel(table)\n * ```\n */\nexport function table_getFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.filteredRowModel) {\n    table._rowModels.filteredRowModel =\n      table.options.features.filteredRowModel?.(table)\n  }\n\n  if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {\n    return table.getPreFilteredRowModel()\n  }\n\n  return table._rowModels.filteredRowModel()\n}\n\n/**\n * Reads the row model immediately before grouping.\n *\n * Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeGrouping = table_getPreGroupedRowModel(table)\n * ```\n */\nexport function table_getPreGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getFilteredRowModel()\n}\n\n/**\n * Resolves the row model after grouping has produced grouped and aggregated rows.\n *\n * When `manualGrouping` is enabled, or no grouped row-model factory was\n * registered, this returns the pre-grouped row model unchanged.\n *\n * @example\n * ```ts\n * const groupedRows = table_getGroupedRowModel(table)\n * ```\n */\nexport function table_getGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.groupedRowModel) {\n    table._rowModels.groupedRowModel =\n      table.options.features.groupedRowModel?.(table)\n  }\n\n  if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {\n    return table.getPreGroupedRowModel()\n  }\n\n  return table._rowModels.groupedRowModel()\n}\n\n/**\n * Reads the row model immediately before sorting.\n *\n * Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeSorting = table_getPreSortedRowModel(table)\n * ```\n */\nexport function table_getPreSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getGroupedRowModel()\n}\n\n/**\n * Resolves the row model after sorting has been applied.\n *\n * When `manualSorting` is enabled, or no sorted row-model factory was\n * registered, this returns the pre-sorted row model because sorted data is\n * expected to be supplied by the caller.\n *\n * @example\n * ```ts\n * const sortedRows = table_getSortedRowModel(table)\n * ```\n */\nexport function table_getSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.sortedRowModel) {\n    table._rowModels.sortedRowModel =\n      table.options.features.sortedRowModel?.(table)\n  }\n\n  if (table.options.manualSorting || !table._rowModels.sortedRowModel) {\n    return table.getPreSortedRowModel()\n  }\n\n  return table._rowModels.sortedRowModel()\n}\n\n/**\n * Reads the row model immediately before row expansion.\n *\n * Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeExpansion = table_getPreExpandedRowModel(table)\n * ```\n */\nexport function table_getPreExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getSortedRowModel()\n}\n\n/**\n * Resolves the row model after expanded rows have been flattened into view.\n *\n * When `manualExpanding` is enabled, or no expanded row-model factory was\n * registered, this returns the pre-expanded row model unchanged.\n *\n * @example\n * ```ts\n * const expandedRows = table_getExpandedRowModel(table)\n * ```\n */\nexport function table_getExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.expandedRowModel) {\n    table._rowModels.expandedRowModel =\n      table.options.features.expandedRowModel?.(table)\n  }\n\n  if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {\n    return table.getPreExpandedRowModel()\n  }\n\n  return table._rowModels.expandedRowModel()\n}\n\n/**\n * Reads the row model immediately before pagination.\n *\n * Pagination is the final built-in row-model stage, so this aliases\n * `table.getExpandedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforePagination = table_getPrePaginatedRowModel(table)\n * ```\n */\nexport function table_getPrePaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getExpandedRowModel()\n}\n\n/**\n * Resolves the row model after pagination has sliced rows for the current page.\n *\n * When `manualPagination` is enabled, or no paginated row-model factory was\n * registered, this returns the pre-paginated row model because pagination is\n * expected to happen before data reaches the table.\n *\n * @example\n * ```ts\n * const pageRows = table_getPaginatedRowModel(table)\n * ```\n */\nexport function table_getPaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.paginatedRowModel) {\n    table._rowModels.paginatedRowModel =\n      table.options.features.paginatedRowModel?.(table)\n  }\n\n  if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {\n    return table.getPrePaginatedRowModel()\n  }\n\n  return table._rowModels.paginatedRowModel()\n}\n\n/**\n * Resolves the final row model consumed by renderers.\n *\n * This is the end of the built-in row-model pipeline: core -> filtering ->\n * grouping -> sorting -> expanding -> pagination.\n *\n * @example\n * ```ts\n * const visibleRows = table_getRowModel(table)\n * ```\n */\nexport function table_getRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getPaginatedRowModel()\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,sBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,cACpB,MAAM,WAAW,eACf,MAAM,QAAQ,SAAS,eAAe,KAAK,KAC3CA,8CAAqC,CAAC,CAAC,KAAK;CAGhD,OAAO,MAAM,WAAW,aAAa;AACvC;;;;;;;;;;;;AAaA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,gBAAgB;AAC/B;;;;;;;;;;;;;AAcA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBACpB,MAAM,WAAW,mBACf,MAAM,QAAQ,SAAS,mBAAmB,KAAK;CAGnD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;AAYA,SAAgB,4BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;AAaA,SAAgB,yBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,iBACpB,MAAM,WAAW,kBACf,MAAM,QAAQ,SAAS,kBAAkB,KAAK;CAGlD,IAAI,MAAM,QAAQ,kBAAkB,CAAC,MAAM,WAAW,iBACpD,OAAO,MAAM,sBAAsB;CAGrC,OAAO,MAAM,WAAW,gBAAgB;AAC1C;;;;;;;;;;;AAYA,SAAgB,2BAGd,OAAqE;CACrE,OAAO,MAAM,mBAAmB;AAClC;;;;;;;;;;;;;AAcA,SAAgB,wBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,gBACpB,MAAM,WAAW,iBACf,MAAM,QAAQ,SAAS,iBAAiB,KAAK;CAGjD,IAAI,MAAM,QAAQ,iBAAiB,CAAC,MAAM,WAAW,gBACnD,OAAO,MAAM,qBAAqB;CAGpC,OAAO,MAAM,WAAW,eAAe;AACzC;;;;;;;;;;;AAYA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,kBAAkB;AACjC;;;;;;;;;;;;AAaA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBACpB,MAAM,WAAW,mBACf,MAAM,QAAQ,SAAS,mBAAmB,KAAK;CAGnD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;;AAaA,SAAgB,8BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;;AAcA,SAAgB,2BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,mBACpB,MAAM,WAAW,oBACf,MAAM,QAAQ,SAAS,oBAAoB,KAAK;CAGpD,IAAI,MAAM,QAAQ,oBAAoB,CAAC,MAAM,WAAW,mBACtD,OAAO,MAAM,wBAAwB;CAGvC,OAAO,MAAM,WAAW,kBAAkB;AAC5C;;;;;;;;;;;;AAaA,SAAgB,kBAGd,OAAqE;CACrE,OAAO,MAAM,qBAAqB;AACpC"}
+{"version":3,"file":"coreRowModelsFeature.utils.cjs","names":["createCoreRowModel"],"sources":["../../../src/core/row-models/coreRowModelsFeature.utils.ts"],"sourcesContent":["import { createCoreRowModel } from './createCoreRowModel'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\nimport type { RowModel } from './coreRowModelsFeature.types'\n\n/**\n * Resolves the table's unmodified core row model.\n *\n * The factory is created once per table, either from the `coreRowModel` slot on the `features` option\n * or the built-in `createCoreRowModel()`, then reused for later calls.\n *\n * @example\n * ```ts\n * const coreRows = table_getCoreRowModel(table)\n * ```\n */\nexport function table_getCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.coreRowModel) {\n    table._rowModels.coreRowModel =\n      table.options.features.coreRowModel?.(table) ??\n      createCoreRowModel<TFeatures, TData>()(table)\n  }\n\n  return table._rowModels.coreRowModel()\n}\n\n/**\n * Reads the row model immediately before column/global filtering.\n *\n * Filtering is the first derived row-model stage, so this currently aliases\n * `table.getCoreRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeFiltering = table_getPreFilteredRowModel(table)\n * ```\n */\nexport function table_getPreFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getCoreRowModel()\n}\n\n/**\n * Resolves the row model after column and global filtering.\n *\n * When `manualFiltering` is enabled, or no filtered row-model factory was\n * registered, this returns the pre-filtered row model because filtering is\n * expected to happen outside the table.\n *\n * @example\n * ```ts\n * const filteredRows = table_getFilteredRowModel(table)\n * ```\n */\nexport function table_getFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.filteredRowModel) {\n    table._rowModels.filteredRowModel =\n      table.options.features.filteredRowModel?.(table)\n  }\n\n  if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {\n    return table.getPreFilteredRowModel()\n  }\n\n  return table._rowModels.filteredRowModel()\n}\n\n/**\n * Reads the row model immediately before grouping.\n *\n * Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeGrouping = table_getPreGroupedRowModel(table)\n * ```\n */\nexport function table_getPreGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getFilteredRowModel()\n}\n\n/**\n * Resolves the row model after grouping has produced grouped rows.\n *\n * When `manualGrouping` is enabled, or no grouped row-model factory was\n * registered, this returns the pre-grouped row model unchanged.\n *\n * @example\n * ```ts\n * const groupedRows = table_getGroupedRowModel(table)\n * ```\n */\nexport function table_getGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.groupedRowModel) {\n    table._rowModels.groupedRowModel =\n      table.options.features.groupedRowModel?.(table)\n  }\n\n  if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {\n    return table.getPreGroupedRowModel()\n  }\n\n  return table._rowModels.groupedRowModel()\n}\n\n/**\n * Reads the row model immediately before sorting.\n *\n * Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeSorting = table_getPreSortedRowModel(table)\n * ```\n */\nexport function table_getPreSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getGroupedRowModel()\n}\n\n/**\n * Resolves the row model after sorting has been applied.\n *\n * When `manualSorting` is enabled, or no sorted row-model factory was\n * registered, this returns the pre-sorted row model because sorted data is\n * expected to be supplied by the caller.\n *\n * @example\n * ```ts\n * const sortedRows = table_getSortedRowModel(table)\n * ```\n */\nexport function table_getSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.sortedRowModel) {\n    table._rowModels.sortedRowModel =\n      table.options.features.sortedRowModel?.(table)\n  }\n\n  if (table.options.manualSorting || !table._rowModels.sortedRowModel) {\n    return table.getPreSortedRowModel()\n  }\n\n  return table._rowModels.sortedRowModel()\n}\n\n/**\n * Reads the row model immediately before row expansion.\n *\n * Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeExpansion = table_getPreExpandedRowModel(table)\n * ```\n */\nexport function table_getPreExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getSortedRowModel()\n}\n\n/**\n * Resolves the row model after expanded rows have been flattened into view.\n *\n * When `manualExpanding` is enabled, or no expanded row-model factory was\n * registered, this returns the pre-expanded row model unchanged.\n *\n * @example\n * ```ts\n * const expandedRows = table_getExpandedRowModel(table)\n * ```\n */\nexport function table_getExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.expandedRowModel) {\n    table._rowModels.expandedRowModel =\n      table.options.features.expandedRowModel?.(table)\n  }\n\n  if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {\n    return table.getPreExpandedRowModel()\n  }\n\n  return table._rowModels.expandedRowModel()\n}\n\n/**\n * Reads the row model immediately before pagination.\n *\n * Pagination is the final built-in row-model stage, so this aliases\n * `table.getExpandedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforePagination = table_getPrePaginatedRowModel(table)\n * ```\n */\nexport function table_getPrePaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getExpandedRowModel()\n}\n\n/**\n * Resolves the row model after pagination has sliced rows for the current page.\n *\n * When `manualPagination` is enabled, or no paginated row-model factory was\n * registered, this returns the pre-paginated row model because pagination is\n * expected to happen before data reaches the table.\n *\n * @example\n * ```ts\n * const pageRows = table_getPaginatedRowModel(table)\n * ```\n */\nexport function table_getPaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.paginatedRowModel) {\n    table._rowModels.paginatedRowModel =\n      table.options.features.paginatedRowModel?.(table)\n  }\n\n  if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {\n    return table.getPrePaginatedRowModel()\n  }\n\n  return table._rowModels.paginatedRowModel()\n}\n\n/**\n * Resolves the final row model consumed by renderers.\n *\n * This is the end of the built-in row-model pipeline: core -> filtering ->\n * grouping -> sorting -> expanding -> pagination.\n *\n * @example\n * ```ts\n * const visibleRows = table_getRowModel(table)\n * ```\n */\nexport function table_getRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getPaginatedRowModel()\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,sBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,cACpB,MAAM,WAAW,eACf,MAAM,QAAQ,SAAS,eAAe,KAAK,KAC3CA,8CAAqC,CAAC,CAAC,KAAK;CAGhD,OAAO,MAAM,WAAW,aAAa;AACvC;;;;;;;;;;;;AAaA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,gBAAgB;AAC/B;;;;;;;;;;;;;AAcA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBACpB,MAAM,WAAW,mBACf,MAAM,QAAQ,SAAS,mBAAmB,KAAK;CAGnD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;AAYA,SAAgB,4BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;AAaA,SAAgB,yBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,iBACpB,MAAM,WAAW,kBACf,MAAM,QAAQ,SAAS,kBAAkB,KAAK;CAGlD,IAAI,MAAM,QAAQ,kBAAkB,CAAC,MAAM,WAAW,iBACpD,OAAO,MAAM,sBAAsB;CAGrC,OAAO,MAAM,WAAW,gBAAgB;AAC1C;;;;;;;;;;;AAYA,SAAgB,2BAGd,OAAqE;CACrE,OAAO,MAAM,mBAAmB;AAClC;;;;;;;;;;;;;AAcA,SAAgB,wBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,gBACpB,MAAM,WAAW,iBACf,MAAM,QAAQ,SAAS,iBAAiB,KAAK;CAGjD,IAAI,MAAM,QAAQ,iBAAiB,CAAC,MAAM,WAAW,gBACnD,OAAO,MAAM,qBAAqB;CAGpC,OAAO,MAAM,WAAW,eAAe;AACzC;;;;;;;;;;;AAYA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,kBAAkB;AACjC;;;;;;;;;;;;AAaA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBACpB,MAAM,WAAW,mBACf,MAAM,QAAQ,SAAS,mBAAmB,KAAK;CAGnD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;;AAaA,SAAgB,8BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;;AAcA,SAAgB,2BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,mBACpB,MAAM,WAAW,oBACf,MAAM,QAAQ,SAAS,oBAAoB,KAAK;CAGpD,IAAI,MAAM,QAAQ,oBAAoB,CAAC,MAAM,WAAW,mBACtD,OAAO,MAAM,wBAAwB;CAGvC,OAAO,MAAM,WAAW,kBAAkB;AAC5C;;;;;;;;;;;;AAaA,SAAgB,kBAGd,OAAqE;CACrE,OAAO,MAAM,qBAAqB;AACpC"}

package/dist/core/row-models/coreRowModelsFeature.utils.d.cts

@@ -53,7 +53,7 @@ declare function table_getFilteredRowModel<TFeatures extends TableFeatures, TDat
  */
 declare function table_getPreGroupedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): RowModel<TFeatures, TData>;
 /**
- * Resolves the row model after grouping has produced grouped and aggregated rows.
+ * Resolves the row model after grouping has produced grouped rows.
  *
  * When `manualGrouping` is enabled, or no grouped row-model factory was
  * registered, this returns the pre-grouped row model unchanged.

package/dist/core/row-models/coreRowModelsFeature.utils.d.ts

@@ -53,7 +53,7 @@ declare function table_getFilteredRowModel<TFeatures extends TableFeatures, TDat
  */
 declare function table_getPreGroupedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): RowModel<TFeatures, TData>;
 /**
- * Resolves the row model after grouping has produced grouped and aggregated rows.
+ * Resolves the row model after grouping has produced grouped rows.
  *
  * When `manualGrouping` is enabled, or no grouped row-model factory was
  * registered, this returns the pre-grouped row model unchanged.

package/dist/core/row-models/coreRowModelsFeature.utils.js

@@ -61,7 +61,7 @@ function table_getPreGroupedRowModel(table) {
 	return table.getFilteredRowModel();
 }
 /**
-* Resolves the row model after grouping has produced grouped and aggregated rows.
+* Resolves the row model after grouping has produced grouped rows.
 *
 * When `manualGrouping` is enabled, or no grouped row-model factory was
 * registered, this returns the pre-grouped row model unchanged.

package/dist/core/row-models/coreRowModelsFeature.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"coreRowModelsFeature.utils.js","names":[],"sources":["../../../src/core/row-models/coreRowModelsFeature.utils.ts"],"sourcesContent":["import { createCoreRowModel } from './createCoreRowModel'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\nimport type { RowModel } from './coreRowModelsFeature.types'\n\n/**\n * Resolves the table's unmodified core row model.\n *\n * The factory is created once per table, either from the `coreRowModel` slot on the `features` option\n * or the built-in `createCoreRowModel()`, then reused for later calls.\n *\n * @example\n * ```ts\n * const coreRows = table_getCoreRowModel(table)\n * ```\n */\nexport function table_getCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.coreRowModel) {\n    table._rowModels.coreRowModel =\n      table.options.features.coreRowModel?.(table) ??\n      createCoreRowModel<TFeatures, TData>()(table)\n  }\n\n  return table._rowModels.coreRowModel()\n}\n\n/**\n * Reads the row model immediately before column/global filtering.\n *\n * Filtering is the first derived row-model stage, so this currently aliases\n * `table.getCoreRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeFiltering = table_getPreFilteredRowModel(table)\n * ```\n */\nexport function table_getPreFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getCoreRowModel()\n}\n\n/**\n * Resolves the row model after column and global filtering.\n *\n * When `manualFiltering` is enabled, or no filtered row-model factory was\n * registered, this returns the pre-filtered row model because filtering is\n * expected to happen outside the table.\n *\n * @example\n * ```ts\n * const filteredRows = table_getFilteredRowModel(table)\n * ```\n */\nexport function table_getFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.filteredRowModel) {\n    table._rowModels.filteredRowModel =\n      table.options.features.filteredRowModel?.(table)\n  }\n\n  if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {\n    return table.getPreFilteredRowModel()\n  }\n\n  return table._rowModels.filteredRowModel()\n}\n\n/**\n * Reads the row model immediately before grouping.\n *\n * Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeGrouping = table_getPreGroupedRowModel(table)\n * ```\n */\nexport function table_getPreGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getFilteredRowModel()\n}\n\n/**\n * Resolves the row model after grouping has produced grouped and aggregated rows.\n *\n * When `manualGrouping` is enabled, or no grouped row-model factory was\n * registered, this returns the pre-grouped row model unchanged.\n *\n * @example\n * ```ts\n * const groupedRows = table_getGroupedRowModel(table)\n * ```\n */\nexport function table_getGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.groupedRowModel) {\n    table._rowModels.groupedRowModel =\n      table.options.features.groupedRowModel?.(table)\n  }\n\n  if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {\n    return table.getPreGroupedRowModel()\n  }\n\n  return table._rowModels.groupedRowModel()\n}\n\n/**\n * Reads the row model immediately before sorting.\n *\n * Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeSorting = table_getPreSortedRowModel(table)\n * ```\n */\nexport function table_getPreSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getGroupedRowModel()\n}\n\n/**\n * Resolves the row model after sorting has been applied.\n *\n * When `manualSorting` is enabled, or no sorted row-model factory was\n * registered, this returns the pre-sorted row model because sorted data is\n * expected to be supplied by the caller.\n *\n * @example\n * ```ts\n * const sortedRows = table_getSortedRowModel(table)\n * ```\n */\nexport function table_getSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.sortedRowModel) {\n    table._rowModels.sortedRowModel =\n      table.options.features.sortedRowModel?.(table)\n  }\n\n  if (table.options.manualSorting || !table._rowModels.sortedRowModel) {\n    return table.getPreSortedRowModel()\n  }\n\n  return table._rowModels.sortedRowModel()\n}\n\n/**\n * Reads the row model immediately before row expansion.\n *\n * Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeExpansion = table_getPreExpandedRowModel(table)\n * ```\n */\nexport function table_getPreExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getSortedRowModel()\n}\n\n/**\n * Resolves the row model after expanded rows have been flattened into view.\n *\n * When `manualExpanding` is enabled, or no expanded row-model factory was\n * registered, this returns the pre-expanded row model unchanged.\n *\n * @example\n * ```ts\n * const expandedRows = table_getExpandedRowModel(table)\n * ```\n */\nexport function table_getExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.expandedRowModel) {\n    table._rowModels.expandedRowModel =\n      table.options.features.expandedRowModel?.(table)\n  }\n\n  if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {\n    return table.getPreExpandedRowModel()\n  }\n\n  return table._rowModels.expandedRowModel()\n}\n\n/**\n * Reads the row model immediately before pagination.\n *\n * Pagination is the final built-in row-model stage, so this aliases\n * `table.getExpandedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforePagination = table_getPrePaginatedRowModel(table)\n * ```\n */\nexport function table_getPrePaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getExpandedRowModel()\n}\n\n/**\n * Resolves the row model after pagination has sliced rows for the current page.\n *\n * When `manualPagination` is enabled, or no paginated row-model factory was\n * registered, this returns the pre-paginated row model because pagination is\n * expected to happen before data reaches the table.\n *\n * @example\n * ```ts\n * const pageRows = table_getPaginatedRowModel(table)\n * ```\n */\nexport function table_getPaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.paginatedRowModel) {\n    table._rowModels.paginatedRowModel =\n      table.options.features.paginatedRowModel?.(table)\n  }\n\n  if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {\n    return table.getPrePaginatedRowModel()\n  }\n\n  return table._rowModels.paginatedRowModel()\n}\n\n/**\n * Resolves the final row model consumed by renderers.\n *\n * This is the end of the built-in row-model pipeline: core -> filtering ->\n * grouping -> sorting -> expanding -> pagination.\n *\n * @example\n * ```ts\n * const visibleRows = table_getRowModel(table)\n * ```\n */\nexport function table_getRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getPaginatedRowModel()\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,sBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,cACpB,MAAM,WAAW,eACf,MAAM,QAAQ,SAAS,eAAe,KAAK,KAC3C,mBAAqC,CAAC,CAAC,KAAK;CAGhD,OAAO,MAAM,WAAW,aAAa;AACvC;;;;;;;;;;;;AAaA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,gBAAgB;AAC/B;;;;;;;;;;;;;AAcA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBACpB,MAAM,WAAW,mBACf,MAAM,QAAQ,SAAS,mBAAmB,KAAK;CAGnD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;AAYA,SAAgB,4BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;AAaA,SAAgB,yBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,iBACpB,MAAM,WAAW,kBACf,MAAM,QAAQ,SAAS,kBAAkB,KAAK;CAGlD,IAAI,MAAM,QAAQ,kBAAkB,CAAC,MAAM,WAAW,iBACpD,OAAO,MAAM,sBAAsB;CAGrC,OAAO,MAAM,WAAW,gBAAgB;AAC1C;;;;;;;;;;;AAYA,SAAgB,2BAGd,OAAqE;CACrE,OAAO,MAAM,mBAAmB;AAClC;;;;;;;;;;;;;AAcA,SAAgB,wBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,gBACpB,MAAM,WAAW,iBACf,MAAM,QAAQ,SAAS,iBAAiB,KAAK;CAGjD,IAAI,MAAM,QAAQ,iBAAiB,CAAC,MAAM,WAAW,gBACnD,OAAO,MAAM,qBAAqB;CAGpC,OAAO,MAAM,WAAW,eAAe;AACzC;;;;;;;;;;;AAYA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,kBAAkB;AACjC;;;;;;;;;;;;AAaA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBACpB,MAAM,WAAW,mBACf,MAAM,QAAQ,SAAS,mBAAmB,KAAK;CAGnD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;;AAaA,SAAgB,8BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;;AAcA,SAAgB,2BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,mBACpB,MAAM,WAAW,oBACf,MAAM,QAAQ,SAAS,oBAAoB,KAAK;CAGpD,IAAI,MAAM,QAAQ,oBAAoB,CAAC,MAAM,WAAW,mBACtD,OAAO,MAAM,wBAAwB;CAGvC,OAAO,MAAM,WAAW,kBAAkB;AAC5C;;;;;;;;;;;;AAaA,SAAgB,kBAGd,OAAqE;CACrE,OAAO,MAAM,qBAAqB;AACpC"}
+{"version":3,"file":"coreRowModelsFeature.utils.js","names":[],"sources":["../../../src/core/row-models/coreRowModelsFeature.utils.ts"],"sourcesContent":["import { createCoreRowModel } from './createCoreRowModel'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\nimport type { RowModel } from './coreRowModelsFeature.types'\n\n/**\n * Resolves the table's unmodified core row model.\n *\n * The factory is created once per table, either from the `coreRowModel` slot on the `features` option\n * or the built-in `createCoreRowModel()`, then reused for later calls.\n *\n * @example\n * ```ts\n * const coreRows = table_getCoreRowModel(table)\n * ```\n */\nexport function table_getCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.coreRowModel) {\n    table._rowModels.coreRowModel =\n      table.options.features.coreRowModel?.(table) ??\n      createCoreRowModel<TFeatures, TData>()(table)\n  }\n\n  return table._rowModels.coreRowModel()\n}\n\n/**\n * Reads the row model immediately before column/global filtering.\n *\n * Filtering is the first derived row-model stage, so this currently aliases\n * `table.getCoreRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeFiltering = table_getPreFilteredRowModel(table)\n * ```\n */\nexport function table_getPreFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getCoreRowModel()\n}\n\n/**\n * Resolves the row model after column and global filtering.\n *\n * When `manualFiltering` is enabled, or no filtered row-model factory was\n * registered, this returns the pre-filtered row model because filtering is\n * expected to happen outside the table.\n *\n * @example\n * ```ts\n * const filteredRows = table_getFilteredRowModel(table)\n * ```\n */\nexport function table_getFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.filteredRowModel) {\n    table._rowModels.filteredRowModel =\n      table.options.features.filteredRowModel?.(table)\n  }\n\n  if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {\n    return table.getPreFilteredRowModel()\n  }\n\n  return table._rowModels.filteredRowModel()\n}\n\n/**\n * Reads the row model immediately before grouping.\n *\n * Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeGrouping = table_getPreGroupedRowModel(table)\n * ```\n */\nexport function table_getPreGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getFilteredRowModel()\n}\n\n/**\n * Resolves the row model after grouping has produced grouped rows.\n *\n * When `manualGrouping` is enabled, or no grouped row-model factory was\n * registered, this returns the pre-grouped row model unchanged.\n *\n * @example\n * ```ts\n * const groupedRows = table_getGroupedRowModel(table)\n * ```\n */\nexport function table_getGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.groupedRowModel) {\n    table._rowModels.groupedRowModel =\n      table.options.features.groupedRowModel?.(table)\n  }\n\n  if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {\n    return table.getPreGroupedRowModel()\n  }\n\n  return table._rowModels.groupedRowModel()\n}\n\n/**\n * Reads the row model immediately before sorting.\n *\n * Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeSorting = table_getPreSortedRowModel(table)\n * ```\n */\nexport function table_getPreSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getGroupedRowModel()\n}\n\n/**\n * Resolves the row model after sorting has been applied.\n *\n * When `manualSorting` is enabled, or no sorted row-model factory was\n * registered, this returns the pre-sorted row model because sorted data is\n * expected to be supplied by the caller.\n *\n * @example\n * ```ts\n * const sortedRows = table_getSortedRowModel(table)\n * ```\n */\nexport function table_getSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.sortedRowModel) {\n    table._rowModels.sortedRowModel =\n      table.options.features.sortedRowModel?.(table)\n  }\n\n  if (table.options.manualSorting || !table._rowModels.sortedRowModel) {\n    return table.getPreSortedRowModel()\n  }\n\n  return table._rowModels.sortedRowModel()\n}\n\n/**\n * Reads the row model immediately before row expansion.\n *\n * Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeExpansion = table_getPreExpandedRowModel(table)\n * ```\n */\nexport function table_getPreExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getSortedRowModel()\n}\n\n/**\n * Resolves the row model after expanded rows have been flattened into view.\n *\n * When `manualExpanding` is enabled, or no expanded row-model factory was\n * registered, this returns the pre-expanded row model unchanged.\n *\n * @example\n * ```ts\n * const expandedRows = table_getExpandedRowModel(table)\n * ```\n */\nexport function table_getExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.expandedRowModel) {\n    table._rowModels.expandedRowModel =\n      table.options.features.expandedRowModel?.(table)\n  }\n\n  if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {\n    return table.getPreExpandedRowModel()\n  }\n\n  return table._rowModels.expandedRowModel()\n}\n\n/**\n * Reads the row model immediately before pagination.\n *\n * Pagination is the final built-in row-model stage, so this aliases\n * `table.getExpandedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforePagination = table_getPrePaginatedRowModel(table)\n * ```\n */\nexport function table_getPrePaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getExpandedRowModel()\n}\n\n/**\n * Resolves the row model after pagination has sliced rows for the current page.\n *\n * When `manualPagination` is enabled, or no paginated row-model factory was\n * registered, this returns the pre-paginated row model because pagination is\n * expected to happen before data reaches the table.\n *\n * @example\n * ```ts\n * const pageRows = table_getPaginatedRowModel(table)\n * ```\n */\nexport function table_getPaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.paginatedRowModel) {\n    table._rowModels.paginatedRowModel =\n      table.options.features.paginatedRowModel?.(table)\n  }\n\n  if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {\n    return table.getPrePaginatedRowModel()\n  }\n\n  return table._rowModels.paginatedRowModel()\n}\n\n/**\n * Resolves the final row model consumed by renderers.\n *\n * This is the end of the built-in row-model pipeline: core -> filtering ->\n * grouping -> sorting -> expanding -> pagination.\n *\n * @example\n * ```ts\n * const visibleRows = table_getRowModel(table)\n * ```\n */\nexport function table_getRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getPaginatedRowModel()\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,sBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,cACpB,MAAM,WAAW,eACf,MAAM,QAAQ,SAAS,eAAe,KAAK,KAC3C,mBAAqC,CAAC,CAAC,KAAK;CAGhD,OAAO,MAAM,WAAW,aAAa;AACvC;;;;;;;;;;;;AAaA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,gBAAgB;AAC/B;;;;;;;;;;;;;AAcA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBACpB,MAAM,WAAW,mBACf,MAAM,QAAQ,SAAS,mBAAmB,KAAK;CAGnD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;AAYA,SAAgB,4BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;AAaA,SAAgB,yBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,iBACpB,MAAM,WAAW,kBACf,MAAM,QAAQ,SAAS,kBAAkB,KAAK;CAGlD,IAAI,MAAM,QAAQ,kBAAkB,CAAC,MAAM,WAAW,iBACpD,OAAO,MAAM,sBAAsB;CAGrC,OAAO,MAAM,WAAW,gBAAgB;AAC1C;;;;;;;;;;;AAYA,SAAgB,2BAGd,OAAqE;CACrE,OAAO,MAAM,mBAAmB;AAClC;;;;;;;;;;;;;AAcA,SAAgB,wBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,gBACpB,MAAM,WAAW,iBACf,MAAM,QAAQ,SAAS,iBAAiB,KAAK;CAGjD,IAAI,MAAM,QAAQ,iBAAiB,CAAC,MAAM,WAAW,gBACnD,OAAO,MAAM,qBAAqB;CAGpC,OAAO,MAAM,WAAW,eAAe;AACzC;;;;;;;;;;;AAYA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,kBAAkB;AACjC;;;;;;;;;;;;AAaA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBACpB,MAAM,WAAW,mBACf,MAAM,QAAQ,SAAS,mBAAmB,KAAK;CAGnD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;;AAaA,SAAgB,8BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;;AAcA,SAAgB,2BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,mBACpB,MAAM,WAAW,oBACf,MAAM,QAAQ,SAAS,oBAAoB,KAAK;CAGpD,IAAI,MAAM,QAAQ,oBAAoB,CAAC,MAAM,WAAW,mBACtD,OAAO,MAAM,wBAAwB;CAGvC,OAAO,MAAM,WAAW,kBAAkB;AAC5C;;;;;;;;;;;;AAaA,SAAgB,kBAGd,OAAqE;CACrE,OAAO,MAAM,qBAAqB;AACpC"}

package/dist/features/aggregation/aggregationFeature.cjs

@@ -0,0 +1,38 @@
+const require_utils = require('../../utils.cjs');
+const require_aggregationFeature_utils = require('./aggregationFeature.utils.cjs');
+
+//#region src/features/aggregation/aggregationFeature.ts
+/**
+* Independent aggregation feature for grouped values and root/custom-row totals.
+*/
+const aggregationFeature = {
+	getDefaultColumnDef: () => ({
+		aggregatedCell: ({ column, getValue }) => require_aggregationFeature_utils.formatAggregatedCellValue(getValue(), column.columnDef.aggregationFn),
+		aggregationFn: "auto"
+	}),
+	getDefaultTableOptions: () => ({ manualAggregation: false }),
+	assignCellPrototype: (prototype, table) => {
+		require_utils.assignPrototypeAPIs("aggregationFeature", prototype, table, { cell_getIsAggregated: { fn: (cell) => require_aggregationFeature_utils.cell_getIsAggregated(cell) } });
+	},
+	assignColumnPrototype: (prototype, table) => {
+		require_utils.assignPrototypeAPIs("aggregationFeature", prototype, table, {
+			column_getAggregationFns: { fn: (column) => require_aggregationFeature_utils.column_getAggregationFns(column) },
+			column_getAggregationValue: { fn: (column, rows) => require_aggregationFeature_utils.column_getAggregationValue(column, rows) },
+			column_getAutoAggregationFn: {
+				fn: (column) => require_aggregationFeature_utils.column_getAutoAggregationFn(column),
+				memoDeps: (column) => [column.table.getCoreRowModel(), column.table._rowModelFns.aggregationFns]
+			}
+		});
+	},
+	initColumnInstanceData: (column) => {
+		column._aggregationValueCache = void 0;
+		column._resolvedAggregationFnsCache = void 0;
+	},
+	initRowInstanceData: (row) => {
+		row._aggregationValuesCache = require_utils.makeObjectMap();
+	}
+};
+
+//#endregion
+exports.aggregationFeature = aggregationFeature;
+//# sourceMappingURL=aggregationFeature.cjs.map

package/dist/features/aggregation/aggregationFeature.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregationFeature.cjs","names":["formatAggregatedCellValue","cell_getIsAggregated","column_getAggregationFns","column_getAggregationValue","column_getAutoAggregationFn","makeObjectMap"],"sources":["../../../src/features/aggregation/aggregationFeature.ts"],"sourcesContent":["import { assignPrototypeAPIs, makeObjectMap } from '../../utils'\nimport {\n  cell_getIsAggregated,\n  column_getAggregationFns,\n  column_getAggregationValue,\n  column_getAutoAggregationFn,\n  formatAggregatedCellValue,\n} from './aggregationFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Independent aggregation feature for grouped values and root/custom-row totals.\n */\nexport const aggregationFeature: TableFeature = {\n  getDefaultColumnDef: () => ({\n    aggregatedCell: ({ column, getValue }: any) =>\n      formatAggregatedCellValue(getValue(), column.columnDef.aggregationFn),\n    aggregationFn: 'auto',\n  }),\n\n  getDefaultTableOptions: () => ({\n    manualAggregation: false,\n  }),\n\n  assignCellPrototype: (prototype, table) => {\n    assignPrototypeAPIs('aggregationFeature', prototype, table, {\n      cell_getIsAggregated: {\n        fn: (cell) => cell_getIsAggregated(cell),\n      },\n    })\n  },\n\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('aggregationFeature', prototype, table, {\n      column_getAggregationFns: {\n        fn: (column) => column_getAggregationFns(column),\n      },\n      column_getAggregationValue: {\n        fn: (column, rows) => column_getAggregationValue(column, rows),\n      },\n      column_getAutoAggregationFn: {\n        fn: (column) => column_getAutoAggregationFn(column),\n        memoDeps: (column) => [\n          column.table.getCoreRowModel(),\n          column.table._rowModelFns.aggregationFns,\n        ],\n      },\n    })\n  },\n\n  initColumnInstanceData: (column) => {\n    ;(column as any)._aggregationValueCache = undefined\n    ;(column as any)._resolvedAggregationFnsCache = undefined\n  },\n\n  initRowInstanceData: (row) => {\n    ;(row as any)._aggregationValuesCache = makeObjectMap()\n  },\n}\n"],"mappings":";;;;;;;AAaA,MAAa,qBAAmC;CAC9C,4BAA4B;EAC1B,iBAAiB,EAAE,QAAQ,eACzBA,2DAA0B,SAAS,GAAG,OAAO,UAAU,aAAa;EACtE,eAAe;CACjB;CAEA,+BAA+B,EAC7B,mBAAmB,MACrB;CAEA,sBAAsB,WAAW,UAAU;EACzC,kCAAoB,sBAAsB,WAAW,OAAO,EAC1D,sBAAsB,EACpB,KAAK,SAASC,sDAAqB,IAAI,EACzC,EACF,CAAC;CACH;CAEA,wBAAwB,WAAW,UAAU;EAC3C,kCAAoB,sBAAsB,WAAW,OAAO;GAC1D,0BAA0B,EACxB,KAAK,WAAWC,0DAAyB,MAAM,EACjD;GACA,4BAA4B,EAC1B,KAAK,QAAQ,SAASC,4DAA2B,QAAQ,IAAI,EAC/D;GACA,6BAA6B;IAC3B,KAAK,WAAWC,6DAA4B,MAAM;IAClD,WAAW,WAAW,CACpB,OAAO,MAAM,gBAAgB,GAC7B,OAAO,MAAM,aAAa,cAC5B;GACF;EACF,CAAC;CACH;CAEA,yBAAyB,WAAW;EACjC,AAAC,OAAe,yBAAyB;EACzC,AAAC,OAAe,+BAA+B;CAClD;CAEA,sBAAsB,QAAQ;EAC3B,AAAC,IAAY,0BAA0BC,4BAAc;CACxD;AACF"}

package/dist/features/aggregation/aggregationFeature.d.cts

@@ -0,0 +1,10 @@
+import { TableFeature } from "../../types/TableFeatures.cjs";
+
+//#region src/features/aggregation/aggregationFeature.d.ts
+/**
+ * Independent aggregation feature for grouped values and root/custom-row totals.
+ */
+declare const aggregationFeature: TableFeature;
+//#endregion
+export { aggregationFeature };
+//# sourceMappingURL=aggregationFeature.d.cts.map

package/dist/features/aggregation/aggregationFeature.d.ts

@@ -0,0 +1,10 @@
+import { TableFeature } from "../../types/TableFeatures.js";
+
+//#region src/features/aggregation/aggregationFeature.d.ts
+/**
+ * Independent aggregation feature for grouped values and root/custom-row totals.
+ */
+declare const aggregationFeature: TableFeature;
+//#endregion
+export { aggregationFeature };
+//# sourceMappingURL=aggregationFeature.d.ts.map

package/dist/features/aggregation/aggregationFeature.js

@@ -0,0 +1,38 @@
+import { assignPrototypeAPIs, makeObjectMap } from "../../utils.js";
+import { cell_getIsAggregated, column_getAggregationFns, column_getAggregationValue, column_getAutoAggregationFn, formatAggregatedCellValue } from "./aggregationFeature.utils.js";
+
+//#region src/features/aggregation/aggregationFeature.ts
+/**
+* Independent aggregation feature for grouped values and root/custom-row totals.
+*/
+const aggregationFeature = {
+	getDefaultColumnDef: () => ({
+		aggregatedCell: ({ column, getValue }) => formatAggregatedCellValue(getValue(), column.columnDef.aggregationFn),
+		aggregationFn: "auto"
+	}),
+	getDefaultTableOptions: () => ({ manualAggregation: false }),
+	assignCellPrototype: (prototype, table) => {
+		assignPrototypeAPIs("aggregationFeature", prototype, table, { cell_getIsAggregated: { fn: (cell) => cell_getIsAggregated(cell) } });
+	},
+	assignColumnPrototype: (prototype, table) => {
+		assignPrototypeAPIs("aggregationFeature", prototype, table, {
+			column_getAggregationFns: { fn: (column) => column_getAggregationFns(column) },
+			column_getAggregationValue: { fn: (column, rows) => column_getAggregationValue(column, rows) },
+			column_getAutoAggregationFn: {
+				fn: (column) => column_getAutoAggregationFn(column),
+				memoDeps: (column) => [column.table.getCoreRowModel(), column.table._rowModelFns.aggregationFns]
+			}
+		});
+	},
+	initColumnInstanceData: (column) => {
+		column._aggregationValueCache = void 0;
+		column._resolvedAggregationFnsCache = void 0;
+	},
+	initRowInstanceData: (row) => {
+		row._aggregationValuesCache = makeObjectMap();
+	}
+};
+
+//#endregion
+export { aggregationFeature };
+//# sourceMappingURL=aggregationFeature.js.map

package/dist/features/aggregation/aggregationFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregationFeature.js","names":[],"sources":["../../../src/features/aggregation/aggregationFeature.ts"],"sourcesContent":["import { assignPrototypeAPIs, makeObjectMap } from '../../utils'\nimport {\n  cell_getIsAggregated,\n  column_getAggregationFns,\n  column_getAggregationValue,\n  column_getAutoAggregationFn,\n  formatAggregatedCellValue,\n} from './aggregationFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Independent aggregation feature for grouped values and root/custom-row totals.\n */\nexport const aggregationFeature: TableFeature = {\n  getDefaultColumnDef: () => ({\n    aggregatedCell: ({ column, getValue }: any) =>\n      formatAggregatedCellValue(getValue(), column.columnDef.aggregationFn),\n    aggregationFn: 'auto',\n  }),\n\n  getDefaultTableOptions: () => ({\n    manualAggregation: false,\n  }),\n\n  assignCellPrototype: (prototype, table) => {\n    assignPrototypeAPIs('aggregationFeature', prototype, table, {\n      cell_getIsAggregated: {\n        fn: (cell) => cell_getIsAggregated(cell),\n      },\n    })\n  },\n\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('aggregationFeature', prototype, table, {\n      column_getAggregationFns: {\n        fn: (column) => column_getAggregationFns(column),\n      },\n      column_getAggregationValue: {\n        fn: (column, rows) => column_getAggregationValue(column, rows),\n      },\n      column_getAutoAggregationFn: {\n        fn: (column) => column_getAutoAggregationFn(column),\n        memoDeps: (column) => [\n          column.table.getCoreRowModel(),\n          column.table._rowModelFns.aggregationFns,\n        ],\n      },\n    })\n  },\n\n  initColumnInstanceData: (column) => {\n    ;(column as any)._aggregationValueCache = undefined\n    ;(column as any)._resolvedAggregationFnsCache = undefined\n  },\n\n  initRowInstanceData: (row) => {\n    ;(row as any)._aggregationValuesCache = makeObjectMap()\n  },\n}\n"],"mappings":";;;;;;;AAaA,MAAa,qBAAmC;CAC9C,4BAA4B;EAC1B,iBAAiB,EAAE,QAAQ,eACzB,0BAA0B,SAAS,GAAG,OAAO,UAAU,aAAa;EACtE,eAAe;CACjB;CAEA,+BAA+B,EAC7B,mBAAmB,MACrB;CAEA,sBAAsB,WAAW,UAAU;EACzC,oBAAoB,sBAAsB,WAAW,OAAO,EAC1D,sBAAsB,EACpB,KAAK,SAAS,qBAAqB,IAAI,EACzC,EACF,CAAC;CACH;CAEA,wBAAwB,WAAW,UAAU;EAC3C,oBAAoB,sBAAsB,WAAW,OAAO;GAC1D,0BAA0B,EACxB,KAAK,WAAW,yBAAyB,MAAM,EACjD;GACA,4BAA4B,EAC1B,KAAK,QAAQ,SAAS,2BAA2B,QAAQ,IAAI,EAC/D;GACA,6BAA6B;IAC3B,KAAK,WAAW,4BAA4B,MAAM;IAClD,WAAW,WAAW,CACpB,OAAO,MAAM,gBAAgB,GAC7B,OAAO,MAAM,aAAa,cAC5B;GACF;EACF,CAAC;CACH;CAEA,yBAAyB,WAAW;EACjC,AAAC,OAAe,yBAAyB;EACzC,AAAC,OAAe,+BAA+B;CAClD;CAEA,sBAAsB,QAAQ;EAC3B,AAAC,IAAY,0BAA0B,cAAc;CACxD;AACF"}

package/dist/features/aggregation/aggregationFeature.types.cjs

@@ -0,0 +1,13 @@
+
+//#region src/features/aggregation/aggregationFeature.types.ts
+/**
+* Creates a typed context-based aggregation definition for a column or
+* aggregation-function registry.
+*/
+function constructAggregationFn(definition) {
+	return definition;
+}
+
+//#endregion
+exports.constructAggregationFn = constructAggregationFn;
+//# sourceMappingURL=aggregationFeature.types.cjs.map

package/dist/features/aggregation/aggregationFeature.types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregationFeature.types.cjs","names":[],"sources":["../../../src/features/aggregation/aggregationFeature.types.ts"],"sourcesContent":["import type { BuiltInAggregationFn } from './aggregationFns'\nimport type { Cell } from '../../types/Cell'\nimport type { Column } from '../../types/Column'\nimport type { ColumnDefTemplate } from '../../types/ColumnDef'\nimport type { IsAny, TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Table } from '../../types/Table'\nimport type { CellData, RowData } from '../../types/type-utils'\n\n/** Declaration-merging fallback for named aggregation definitions. */\nexport interface AggregationFns {}\n\n/** Values and table objects available while one aggregation is evaluated. */\nexport interface AggregationContext<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue = unknown,\n> {\n  /** The column whose values are being aggregated. */\n  column: Column<TFeatures, TData, TValue>\n  /** Convenience alias for `column.id`. */\n  columnId: string\n  /** Reads this column's value from one of `rows`. */\n  getValue: (row: Row<TFeatures, TData>) => TValue\n  /**\n   * The synthetic grouped row receiving this result. This property is omitted\n   * for root or caller-supplied-row aggregation. Its `depth` identifies the\n   * grouping level when grouped aggregation needs that distinction.\n   */\n  groupingRow?: Row<TFeatures, TData>\n  /**\n   * Terminal leaf rows included in this aggregation. The executor normalizes\n   * hierarchical and duplicate row inputs before invoking the definition.\n   */\n  rows: ReadonlyArray<Row<TFeatures, TData>>\n  /** The table that owns the column and rows. */\n  table: Table<TFeatures, TData>\n}\n\n/** Additional values available when merging nested grouped results. */\nexport interface AggregationMergeContext<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue,\n  TResult,\n> extends AggregationContext<TFeatures, TData, TValue> {\n  /** Results produced for each immediate child group, in child-row order. */\n  childResults: ReadonlyArray<TResult>\n  /** Immediate child group rows corresponding to `childResults`. */\n  childRows: ReadonlyArray<Row<TFeatures, TData>>\n}\n\n/** A context-based aggregation definition and optional grouped-result merge. */\nexport interface AggregationFnDef<\n  TFeatures extends TableFeatures = any,\n  TData extends RowData = any,\n  TValue = unknown,\n  TResult = unknown,\n> {\n  /** Computes a result directly from normalized terminal rows. */\n  aggregate: (context: AggregationContext<TFeatures, TData, TValue>) => TResult\n  /**\n   * Combines already-computed immediate child-group results. When omitted,\n   * nested grouping falls back to `aggregate` over the group's terminal rows.\n   */\n  merge?: (\n    context: AggregationMergeContext<TFeatures, TData, TValue, TResult>,\n  ) => TResult\n}\n\n/**\n * Creates a typed context-based aggregation definition for a column or\n * aggregation-function registry.\n */\nexport function constructAggregationFn<\n  TFeatures extends TableFeatures = any,\n  TData extends RowData = any,\n  TValue = unknown,\n  TResult = unknown,\n>(\n  definition: AggregationFnDef<TFeatures, TData, TValue, TResult>,\n): AggregationFnDef<TFeatures, TData, TValue, TResult> {\n  return definition\n}\n\n/** Aggregation-definition registry carried by a table feature set. */\nexport interface RowModelFns_Aggregation<\n  in out TFeatures extends TableFeatures,\n  in out TData extends RowData,\n> {\n  aggregationFns: Record<string, AggregationFnDef<TFeatures, TData, any, any>>\n}\n\n/** Named context-based aggregation definitions registered on a feature set. */\nexport type CustomAggregationFns<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> = Record<string, AggregationFnDef<TFeatures, TData, any, any>>\n\n/** String names available from a feature set's aggregation registry. */\nexport type ExtractAggregationFnKeys<TFeatures extends TableFeatures> =\n  IsAny<TFeatures> extends true\n    ? keyof AggregationFns | BuiltInAggregationFn\n    : TFeatures extends { aggregationFns: infer TAggregationFns extends object }\n      ? Extract<keyof TAggregationFns, string>\n      : keyof AggregationFns\n\n/** A registered name, automatic inference, or inline aggregation definition. */\nexport type AggregationFnRef<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue = unknown,\n  TResult = unknown,\n> =\n  | 'auto'\n  | ExtractAggregationFnKeys<TFeatures>\n  | AggregationFnDef<TFeatures, TData, TValue, TResult>\n\n/** Gives an aggregation reference a stable key in a multiple result. */\nexport interface AggregationFnDescriptor<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue = unknown,\n  TResult = unknown,\n> {\n  /** The named, automatic, or inline definition to execute. */\n  aggregationFn: AggregationFnRef<TFeatures, TData, TValue, TResult>\n  /** Stable key used in the object returned by a multiple aggregation. */\n  id: string\n}\n\n/** One named or explicitly keyed entry in a multiple aggregation option. */\nexport type AggregationFnListItem<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue = unknown,\n> =\n  | 'auto'\n  | ExtractAggregationFnKeys<TFeatures>\n  | AggregationFnDescriptor<TFeatures, TData, TValue, any>\n\n/** A scalar aggregation reference or a list that produces a keyed object. */\nexport type AggregationFnOption<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue = unknown,\n> =\n  | AggregationFnRef<TFeatures, TData, TValue, any>\n  | ReadonlyArray<AggregationFnListItem<TFeatures, TData, TValue>>\n\n/** Extracts the result type produced by an aggregation definition. */\nexport type AggregationResultOf<TDefinition> =\n  TDefinition extends AggregationFnDef<any, any, any, infer TResult>\n    ? TResult\n    : unknown\n\ntype RegisteredAggregationDefinition<\n  TFeatures extends TableFeatures,\n  TKey extends PropertyKey,\n> = TFeatures extends {\n  aggregationFns: infer TRegistry extends Record<PropertyKey, unknown>\n}\n  ? TKey extends keyof TRegistry\n    ? TRegistry[TKey]\n    : never\n  : never\n\ntype AggregationResultOfRef<TRef, TFeatures extends TableFeatures> =\n  TRef extends AggregationFnDef<any, any, any, any>\n    ? AggregationResultOf<TRef>\n    : TRef extends 'auto'\n      ? RegisteredAggregationResult<TFeatures>\n      : TRef extends PropertyKey\n        ? AggregationResultOf<RegisteredAggregationDefinition<TFeatures, TRef>>\n        : unknown\n\ntype AggregationEntryId<TEntry> = TEntry extends string\n  ? TEntry\n  : TEntry extends { id: infer TId extends string }\n    ? TId\n    : never\n\ntype AggregationEntryDefinition<TEntry> = TEntry extends {\n  aggregationFn: infer TDefinition\n}\n  ? TDefinition\n  : TEntry\n\n/** Infers the scalar or keyed result produced by an aggregation option. */\nexport type AggregationResult<TOption, TFeatures extends TableFeatures = any> =\n  TOption extends ReadonlyArray<infer TEntry>\n    ? {\n        [TKey in AggregationEntryId<TEntry>]: AggregationResultOfRef<\n          AggregationEntryDefinition<Extract<TEntry, TKey | { id: TKey }>>,\n          TFeatures\n        >\n      }\n    : AggregationResultOfRef<TOption, TFeatures>\n\ntype RegisteredAggregationResult<TFeatures extends TableFeatures> =\n  TFeatures extends {\n    aggregationFns: infer TRegistry extends Record<string, unknown>\n  }\n    ? AggregationResultOf<TRegistry[keyof TRegistry]>\n    : unknown\n\n/** Default public result union when a column's precise option is not known. */\nexport type ColumnAggregationValue<TFeatures extends TableFeatures> =\n  | RegisteredAggregationResult<TFeatures>\n  | Record<string, RegisteredAggregationResult<TFeatures> | undefined>\n  | undefined\n\n/** A validated aggregation entry returned by `column.getAggregationFns()`. */\nexport interface ResolvedAggregationFn<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  /** Resolved definition, or `undefined` when configuration is invalid. */\n  aggregationFn: AggregationFnDef<TFeatures, TData, any, any> | undefined\n  /** Key used for a multiple result; scalar inline definitions have no id. */\n  id: string | undefined\n}\n\n/** Column-definition options installed by `aggregationFeature`. */\nexport interface ColumnDef_Aggregation<\n  in out TFeatures extends TableFeatures,\n  in out TData extends RowData,\n  TValue extends CellData = CellData,\n> {\n  /** Renderer used for a grouped row's aggregated cell. */\n  aggregatedCell?: ColumnDefTemplate<\n    ReturnType<Cell<TFeatures, TData, TValue>['getContext']>\n  >\n  /**\n   * One aggregation reference for a scalar result, or an array for a keyed\n   * result object. Inline definitions in an array require an explicit `id`.\n   */\n  aggregationFn?: AggregationFnOption<TFeatures, TData, TValue>\n  /**\n   * Optionally supplies a precomputed aggregation value for this column.\n   * Return `{ value }` to handle the request, including `{ value: undefined }`;\n   * return `undefined` to use the local aggregation fallback.\n   */\n  getAggregationValue?: (\n    context: AggregationValueContext<TFeatures, TData, TValue>,\n  ) => AggregationValueResult | undefined\n}\n\n/** Column instance APIs installed by `aggregationFeature`. */\nexport interface Column_Aggregation<\n  in out TFeatures extends TableFeatures,\n  in out TData extends RowData,\n> {\n  /** Resolves the configured scalar or multiple aggregation definitions. */\n  getAggregationFns: () => ReadonlyArray<\n    ResolvedAggregationFn<TFeatures, TData>\n  >\n  /**\n   * Aggregates this column over the default pre-grouped row model, or over a\n   * caller-provided array of rows. Explicit rows are normalized to unique\n   * terminal leaves and are intentionally not cached.\n   */\n  getAggregationValue: <TResult = ColumnAggregationValue<TFeatures>>(\n    rows?: ReadonlyArray<Row<TFeatures, TData>>,\n  ) => TResult\n  /** Infers `sum` for a numeric first row and `extent` for a Date first row. */\n  getAutoAggregationFn: () =>\n    | AggregationFnDef<TFeatures, TData, any, any>\n    | undefined\n}\n\n/** Cell instance APIs installed by `aggregationFeature`. */\nexport interface Cell_Aggregation {\n  /** Whether this cell displays an aggregate on a synthetic grouped row. */\n  getIsAggregated: () => boolean\n}\n\n/** Internal per-row cache used while grouped aggregates are evaluated. */\nexport interface Row_Aggregation {\n  /** Cached aggregate results keyed by column id. */\n  _aggregationValuesCache: Record<string, unknown>\n}\n\n/** Values passed to a column-level aggregation-value provider. */\nexport interface AggregationValueContext<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n> {\n  /** The column whose value was requested. */\n  column: Column<TFeatures, TData, TValue>\n  /** Caller-provided rows, or `undefined` for the default row model. */\n  rows?: ReadonlyArray<Row<TFeatures, TData>>\n  /** The table that owns the column. */\n  table: Table<TFeatures, TData>\n}\n\n/** Marks an aggregation-value override as handled. */\nexport interface AggregationValueResult<TResult = unknown> {\n  /** The supplied value. `undefined` is still a handled result. */\n  value: TResult\n}\n\n/** Table options installed by `aggregationFeature`. */\nexport interface TableOptions_Aggregation {\n  /**\n   * Disables local `column.getAggregationValue()` calculation when a column\n   * override does not handle the request. Group values supplied by manually\n   * grouped rows remain the responsibility of the data owner.\n   */\n  manualAggregation?: boolean\n}\n"],"mappings":";;;;;;AA0EA,SAAgB,uBAMd,YACqD;CACrD,OAAO;AACT"}

package/dist/features/aggregation/aggregationFeature.types.d.cts

@@ -0,0 +1,172 @@
+import { CellData, RowData } from "../../types/type-utils.cjs";
+import { BuiltInAggregationFn } from "./aggregationFns.cjs";
+import { ColumnDefTemplate } from "../../types/ColumnDef.cjs";
+import { Cell } from "../../types/Cell.cjs";
+import { Row } from "../../types/Row.cjs";
+import { Table } from "../../types/Table.cjs";
+import { Column } from "../../types/Column.cjs";
+import { IsAny, TableFeatures } from "../../types/TableFeatures.cjs";
+
+//#region src/features/aggregation/aggregationFeature.types.d.ts
+/** Declaration-merging fallback for named aggregation definitions. */
+interface AggregationFns {}
+/** Values and table objects available while one aggregation is evaluated. */
+interface AggregationContext<TFeatures extends TableFeatures, TData extends RowData, TValue = unknown> {
+  /** The column whose values are being aggregated. */
+  column: Column<TFeatures, TData, TValue>;
+  /** Convenience alias for `column.id`. */
+  columnId: string;
+  /** Reads this column's value from one of `rows`. */
+  getValue: (row: Row<TFeatures, TData>) => TValue;
+  /**
+   * The synthetic grouped row receiving this result. This property is omitted
+   * for root or caller-supplied-row aggregation. Its `depth` identifies the
+   * grouping level when grouped aggregation needs that distinction.
+   */
+  groupingRow?: Row<TFeatures, TData>;
+  /**
+   * Terminal leaf rows included in this aggregation. The executor normalizes
+   * hierarchical and duplicate row inputs before invoking the definition.
+   */
+  rows: ReadonlyArray<Row<TFeatures, TData>>;
+  /** The table that owns the column and rows. */
+  table: Table<TFeatures, TData>;
+}
+/** Additional values available when merging nested grouped results. */
+interface AggregationMergeContext<TFeatures extends TableFeatures, TData extends RowData, TValue, TResult> extends AggregationContext<TFeatures, TData, TValue> {
+  /** Results produced for each immediate child group, in child-row order. */
+  childResults: ReadonlyArray<TResult>;
+  /** Immediate child group rows corresponding to `childResults`. */
+  childRows: ReadonlyArray<Row<TFeatures, TData>>;
+}
+/** A context-based aggregation definition and optional grouped-result merge. */
+interface AggregationFnDef<TFeatures extends TableFeatures = any, TData extends RowData = any, TValue = unknown, TResult = unknown> {
+  /** Computes a result directly from normalized terminal rows. */
+  aggregate: (context: AggregationContext<TFeatures, TData, TValue>) => TResult;
+  /**
+   * Combines already-computed immediate child-group results. When omitted,
+   * nested grouping falls back to `aggregate` over the group's terminal rows.
+   */
+  merge?: (context: AggregationMergeContext<TFeatures, TData, TValue, TResult>) => TResult;
+}
+/**
+ * Creates a typed context-based aggregation definition for a column or
+ * aggregation-function registry.
+ */
+declare function constructAggregationFn<TFeatures extends TableFeatures = any, TData extends RowData = any, TValue = unknown, TResult = unknown>(definition: AggregationFnDef<TFeatures, TData, TValue, TResult>): AggregationFnDef<TFeatures, TData, TValue, TResult>;
+/** Aggregation-definition registry carried by a table feature set. */
+interface RowModelFns_Aggregation<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  aggregationFns: Record<string, AggregationFnDef<TFeatures, TData, any, any>>;
+}
+/** Named context-based aggregation definitions registered on a feature set. */
+type CustomAggregationFns<TFeatures extends TableFeatures, TData extends RowData> = Record<string, AggregationFnDef<TFeatures, TData, any, any>>;
+/** String names available from a feature set's aggregation registry. */
+type ExtractAggregationFnKeys<TFeatures extends TableFeatures> = IsAny<TFeatures> extends true ? keyof AggregationFns | BuiltInAggregationFn : TFeatures extends {
+  aggregationFns: infer TAggregationFns extends object;
+} ? Extract<keyof TAggregationFns, string> : keyof AggregationFns;
+/** A registered name, automatic inference, or inline aggregation definition. */
+type AggregationFnRef<TFeatures extends TableFeatures, TData extends RowData, TValue = unknown, TResult = unknown> = 'auto' | ExtractAggregationFnKeys<TFeatures> | AggregationFnDef<TFeatures, TData, TValue, TResult>;
+/** Gives an aggregation reference a stable key in a multiple result. */
+interface AggregationFnDescriptor<TFeatures extends TableFeatures, TData extends RowData, TValue = unknown, TResult = unknown> {
+  /** The named, automatic, or inline definition to execute. */
+  aggregationFn: AggregationFnRef<TFeatures, TData, TValue, TResult>;
+  /** Stable key used in the object returned by a multiple aggregation. */
+  id: string;
+}
+/** One named or explicitly keyed entry in a multiple aggregation option. */
+type AggregationFnListItem<TFeatures extends TableFeatures, TData extends RowData, TValue = unknown> = 'auto' | ExtractAggregationFnKeys<TFeatures> | AggregationFnDescriptor<TFeatures, TData, TValue, any>;
+/** A scalar aggregation reference or a list that produces a keyed object. */
+type AggregationFnOption<TFeatures extends TableFeatures, TData extends RowData, TValue = unknown> = AggregationFnRef<TFeatures, TData, TValue, any> | ReadonlyArray<AggregationFnListItem<TFeatures, TData, TValue>>;
+/** Extracts the result type produced by an aggregation definition. */
+type AggregationResultOf<TDefinition> = TDefinition extends AggregationFnDef<any, any, any, infer TResult> ? TResult : unknown;
+type RegisteredAggregationDefinition<TFeatures extends TableFeatures, TKey extends PropertyKey> = TFeatures extends {
+  aggregationFns: infer TRegistry extends Record<PropertyKey, unknown>;
+} ? TKey extends keyof TRegistry ? TRegistry[TKey] : never : never;
+type AggregationResultOfRef<TRef, TFeatures extends TableFeatures> = TRef extends AggregationFnDef<any, any, any, any> ? AggregationResultOf<TRef> : TRef extends 'auto' ? RegisteredAggregationResult<TFeatures> : TRef extends PropertyKey ? AggregationResultOf<RegisteredAggregationDefinition<TFeatures, TRef>> : unknown;
+type AggregationEntryId<TEntry> = TEntry extends string ? TEntry : TEntry extends {
+  id: infer TId extends string;
+} ? TId : never;
+type AggregationEntryDefinition<TEntry> = TEntry extends {
+  aggregationFn: infer TDefinition;
+} ? TDefinition : TEntry;
+/** Infers the scalar or keyed result produced by an aggregation option. */
+type AggregationResult<TOption, TFeatures extends TableFeatures = any> = TOption extends ReadonlyArray<infer TEntry> ? { [TKey in AggregationEntryId<TEntry>]: AggregationResultOfRef<AggregationEntryDefinition<Extract<TEntry, TKey | {
+  id: TKey;
+}>>, TFeatures> } : AggregationResultOfRef<TOption, TFeatures>;
+type RegisteredAggregationResult<TFeatures extends TableFeatures> = TFeatures extends {
+  aggregationFns: infer TRegistry extends Record<string, unknown>;
+} ? AggregationResultOf<TRegistry[keyof TRegistry]> : unknown;
+/** Default public result union when a column's precise option is not known. */
+type ColumnAggregationValue<TFeatures extends TableFeatures> = RegisteredAggregationResult<TFeatures> | Record<string, RegisteredAggregationResult<TFeatures> | undefined> | undefined;
+/** A validated aggregation entry returned by `column.getAggregationFns()`. */
+interface ResolvedAggregationFn<TFeatures extends TableFeatures, TData extends RowData> {
+  /** Resolved definition, or `undefined` when configuration is invalid. */
+  aggregationFn: AggregationFnDef<TFeatures, TData, any, any> | undefined;
+  /** Key used for a multiple result; scalar inline definitions have no id. */
+  id: string | undefined;
+}
+/** Column-definition options installed by `aggregationFeature`. */
+interface ColumnDef_Aggregation<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> {
+  /** Renderer used for a grouped row's aggregated cell. */
+  aggregatedCell?: ColumnDefTemplate<ReturnType<Cell<TFeatures, TData, TValue>['getContext']>>;
+  /**
+   * One aggregation reference for a scalar result, or an array for a keyed
+   * result object. Inline definitions in an array require an explicit `id`.
+   */
+  aggregationFn?: AggregationFnOption<TFeatures, TData, TValue>;
+  /**
+   * Optionally supplies a precomputed aggregation value for this column.
+   * Return `{ value }` to handle the request, including `{ value: undefined }`;
+   * return `undefined` to use the local aggregation fallback.
+   */
+  getAggregationValue?: (context: AggregationValueContext<TFeatures, TData, TValue>) => AggregationValueResult | undefined;
+}
+/** Column instance APIs installed by `aggregationFeature`. */
+interface Column_Aggregation<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  /** Resolves the configured scalar or multiple aggregation definitions. */
+  getAggregationFns: () => ReadonlyArray<ResolvedAggregationFn<TFeatures, TData>>;
+  /**
+   * Aggregates this column over the default pre-grouped row model, or over a
+   * caller-provided array of rows. Explicit rows are normalized to unique
+   * terminal leaves and are intentionally not cached.
+   */
+  getAggregationValue: <TResult = ColumnAggregationValue<TFeatures>>(rows?: ReadonlyArray<Row<TFeatures, TData>>) => TResult;
+  /** Infers `sum` for a numeric first row and `extent` for a Date first row. */
+  getAutoAggregationFn: () => AggregationFnDef<TFeatures, TData, any, any> | undefined;
+}
+/** Cell instance APIs installed by `aggregationFeature`. */
+interface Cell_Aggregation {
+  /** Whether this cell displays an aggregate on a synthetic grouped row. */
+  getIsAggregated: () => boolean;
+}
+/** Internal per-row cache used while grouped aggregates are evaluated. */
+interface Row_Aggregation {
+  /** Cached aggregate results keyed by column id. */
+  _aggregationValuesCache: Record<string, unknown>;
+}
+/** Values passed to a column-level aggregation-value provider. */
+interface AggregationValueContext<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> {
+  /** The column whose value was requested. */
+  column: Column<TFeatures, TData, TValue>;
+  /** Caller-provided rows, or `undefined` for the default row model. */
+  rows?: ReadonlyArray<Row<TFeatures, TData>>;
+  /** The table that owns the column. */
+  table: Table<TFeatures, TData>;
+}
+/** Marks an aggregation-value override as handled. */
+interface AggregationValueResult<TResult = unknown> {
+  /** The supplied value. `undefined` is still a handled result. */
+  value: TResult;
+}
+/** Table options installed by `aggregationFeature`. */
+interface TableOptions_Aggregation {
+  /**
+   * Disables local `column.getAggregationValue()` calculation when a column
+   * override does not handle the request. Group values supplied by manually
+   * grouped rows remain the responsibility of the data owner.
+   */
+  manualAggregation?: boolean;
+}
+//#endregion
+export { AggregationContext, AggregationFnDef, AggregationFnDescriptor, AggregationFnListItem, AggregationFnOption, AggregationFnRef, AggregationFns, AggregationMergeContext, AggregationResult, AggregationResultOf, AggregationValueContext, AggregationValueResult, Cell_Aggregation, ColumnAggregationValue, ColumnDef_Aggregation, Column_Aggregation, CustomAggregationFns, ExtractAggregationFnKeys, ResolvedAggregationFn, RowModelFns_Aggregation, Row_Aggregation, TableOptions_Aggregation, constructAggregationFn };
+//# sourceMappingURL=aggregationFeature.types.d.cts.map