@tanstack/table-core 9.0.0-beta.7 → 9.0.0-beta.70

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

@@ -1 +0,0 @@
-{"version":3,"file":"coreRowModelsFeature.js","names":[],"sources":["../../../src/core/row-models/coreRowModelsFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport {\n  table_getCoreRowModel,\n  table_getExpandedRowModel,\n  table_getFilteredRowModel,\n  table_getGroupedRowModel,\n  table_getPaginatedRowModel,\n  table_getPreExpandedRowModel,\n  table_getPreFilteredRowModel,\n  table_getPreGroupedRowModel,\n  table_getPrePaginatedRowModel,\n  table_getPreSortedRowModel,\n  table_getRowModel,\n  table_getSortedRowModel,\n} from './coreRowModelsFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Core feature that wires table row-model accessors and row-model caches.\n */\nexport const coreRowModelsFeature: TableFeature = {\n  constructTableAPIs: (table) => {\n    assignTableAPIs('coreRowModelsFeature', table, {\n      table_getCoreRowModel: {\n        fn: () => table_getCoreRowModel(table),\n      },\n      table_getPreFilteredRowModel: {\n        fn: () => table_getPreFilteredRowModel(table),\n      },\n      table_getFilteredRowModel: {\n        fn: () => table_getFilteredRowModel(table),\n      },\n      table_getPreGroupedRowModel: {\n        fn: () => table_getPreGroupedRowModel(table),\n      },\n      table_getGroupedRowModel: {\n        fn: () => table_getGroupedRowModel(table),\n      },\n      table_getPreSortedRowModel: {\n        fn: () => table_getPreSortedRowModel(table),\n      },\n      table_getSortedRowModel: {\n        fn: () => table_getSortedRowModel(table),\n      },\n      table_getPreExpandedRowModel: {\n        fn: () => table_getPreExpandedRowModel(table),\n      },\n      table_getExpandedRowModel: {\n        fn: () => table_getExpandedRowModel(table),\n      },\n      table_getPrePaginatedRowModel: {\n        fn: () => table_getPrePaginatedRowModel(table),\n      },\n      table_getPaginatedRowModel: {\n        fn: () => table_getPaginatedRowModel(table),\n      },\n      table_getRowModel: {\n        fn: () => table_getRowModel(table),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AAoBA,MAAa,uBAAqC,EAChD,qBAAqB,UAAU;CAC7B,gBAAgB,wBAAwB,OAAO;EAC7C,uBAAuB,EACrB,UAAU,sBAAsB,KAAK,EACvC;EACA,8BAA8B,EAC5B,UAAU,6BAA6B,KAAK,EAC9C;EACA,2BAA2B,EACzB,UAAU,0BAA0B,KAAK,EAC3C;EACA,6BAA6B,EAC3B,UAAU,4BAA4B,KAAK,EAC7C;EACA,0BAA0B,EACxB,UAAU,yBAAyB,KAAK,EAC1C;EACA,4BAA4B,EAC1B,UAAU,2BAA2B,KAAK,EAC5C;EACA,yBAAyB,EACvB,UAAU,wBAAwB,KAAK,EACzC;EACA,8BAA8B,EAC5B,UAAU,6BAA6B,KAAK,EAC9C;EACA,2BAA2B,EACzB,UAAU,0BAA0B,KAAK,EAC3C;EACA,+BAA+B,EAC7B,UAAU,8BAA8B,KAAK,EAC/C;EACA,4BAA4B,EAC1B,UAAU,2BAA2B,KAAK,EAC5C;EACA,mBAAmB,EACjB,UAAU,kBAAkB,KAAK,EACnC;CACF,CAAC;AACH,EACF"}

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

@@ -1,41 +0,0 @@
-import { RowData } from "../../types/type-utils.cjs";
-import { Table_RowModels_Sorted } from "../../features/row-sorting/rowSortingFeature.types.cjs";
-import { Table_RowModels_Filtered } from "../../features/column-filtering/columnFilteringFeature.types.cjs";
-import { Table_RowModels_Expanded } from "../../features/row-expanding/rowExpandingFeature.types.cjs";
-import { Row } from "../../types/Row.cjs";
-import { Table_RowModels_Paginated } from "../../features/row-pagination/rowPaginationFeature.types.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-import { Table_RowModels_Faceted } from "../../features/column-faceting/columnFacetingFeature.types.cjs";
-import { Table } from "../../types/Table.cjs";
-import { Table_RowModels_Grouped } from "../../features/column-grouping/columnGroupingFeature.types.cjs";
-
-//#region src/core/row-models/coreRowModelsFeature.types.d.ts
-interface RowModel<TFeatures extends TableFeatures, TData extends RowData> {
-  rows: Array<Row<TFeatures, TData>>;
-  flatRows: Array<Row<TFeatures, TData>>;
-  rowsById: Record<string, Row<TFeatures, TData>>;
-}
-interface CreateRowModel_Core<TFeatures extends TableFeatures, TData extends RowData> {
-  /**
-   * Optional factory for the core row model. When omitted, the built-in
-   * `createCoreRowModel()` factory is used.
-   */
-  coreRowModel?: (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
-}
-interface CachedRowModel_Core<TFeatures extends TableFeatures, TData extends RowData> {
-  coreRowModel: () => RowModel<TFeatures, TData>;
-}
-interface Table_RowModels_Core<TFeatures extends TableFeatures, TData extends RowData> {
-  /**
-   * Returns the core row model before any processing has been applied.
-   */
-  getCoreRowModel: () => RowModel<TFeatures, TData>;
-  /**
-   * Returns the final model after all processing from other used features has been applied. This is the row model that is most commonly used for rendering.
-   */
-  getRowModel: () => RowModel<TFeatures, TData>;
-}
-type Table_RowModels<TFeatures extends TableFeatures, TData extends RowData> = Table_RowModels_Core<TFeatures, TData> & Table_RowModels_Faceted<TFeatures, TData> & Table_RowModels_Filtered<TFeatures, TData> & Table_RowModels_Grouped<TFeatures, TData> & Table_RowModels_Expanded<TFeatures, TData> & Table_RowModels_Paginated<TFeatures, TData> & Table_RowModels_Sorted<TFeatures, TData>;
-//#endregion
-export { CachedRowModel_Core, CreateRowModel_Core, RowModel, Table_RowModels, Table_RowModels_Core };
-//# sourceMappingURL=coreRowModelsFeature.types.d.cts.map

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

@@ -1,215 +0,0 @@
-const require_createCoreRowModel = require('./createCoreRowModel.cjs');
-
-//#region src/core/row-models/coreRowModelsFeature.utils.ts
-/**
-* Resolves the table's unmodified core row model.
-*
-* The factory is created once per table, either from `options.rowModels.coreRowModel`
-* or the built-in `createCoreRowModel()`, then reused for later calls.
-*
-* @example
-* ```ts
-* const coreRows = table_getCoreRowModel(table)
-* ```
-*/
-function table_getCoreRowModel(table) {
-	if (!table._rowModels.coreRowModel) {
-		var _table$options$rowMod, _table$options$rowMod2;
-		table._rowModels.coreRowModel = ((_table$options$rowMod = table.options.rowModels) === null || _table$options$rowMod === void 0 || (_table$options$rowMod2 = _table$options$rowMod.coreRowModel) === null || _table$options$rowMod2 === void 0 ? void 0 : _table$options$rowMod2.call(_table$options$rowMod, table)) ?? require_createCoreRowModel.createCoreRowModel()(table);
-	}
-	return table._rowModels.coreRowModel();
-}
-/**
-* Reads the row model immediately before column/global filtering.
-*
-* Filtering is the first derived row-model stage, so this currently aliases
-* `table.getCoreRowModel()`.
-*
-* @example
-* ```ts
-* const rowsBeforeFiltering = table_getPreFilteredRowModel(table)
-* ```
-*/
-function table_getPreFilteredRowModel(table) {
-	return table.getCoreRowModel();
-}
-/**
-* Resolves the row model after column and global filtering.
-*
-* When `manualFiltering` is enabled, or no filtered row-model factory was
-* registered, this returns the pre-filtered row model because filtering is
-* expected to happen outside the table.
-*
-* @example
-* ```ts
-* const filteredRows = table_getFilteredRowModel(table)
-* ```
-*/
-function table_getFilteredRowModel(table) {
-	if (!table._rowModels.filteredRowModel) {
-		var _table$options$rowMod3, _table$options$rowMod4;
-		table._rowModels.filteredRowModel = (_table$options$rowMod3 = table.options.rowModels) === null || _table$options$rowMod3 === void 0 || (_table$options$rowMod4 = _table$options$rowMod3.filteredRowModel) === null || _table$options$rowMod4 === void 0 ? void 0 : _table$options$rowMod4.call(_table$options$rowMod3, table);
-	}
-	if (table.options.manualFiltering || !table._rowModels.filteredRowModel) return table.getPreFilteredRowModel();
-	return table._rowModels.filteredRowModel();
-}
-/**
-* Reads the row model immediately before grouping.
-*
-* Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.
-*
-* @example
-* ```ts
-* const rowsBeforeGrouping = table_getPreGroupedRowModel(table)
-* ```
-*/
-function table_getPreGroupedRowModel(table) {
-	return table.getFilteredRowModel();
-}
-/**
-* Resolves the row model after grouping has produced grouped and aggregated rows.
-*
-* When `manualGrouping` is enabled, or no grouped row-model factory was
-* registered, this returns the pre-grouped row model unchanged.
-*
-* @example
-* ```ts
-* const groupedRows = table_getGroupedRowModel(table)
-* ```
-*/
-function table_getGroupedRowModel(table) {
-	if (!table._rowModels.groupedRowModel) {
-		var _table$options$rowMod5, _table$options$rowMod6;
-		table._rowModels.groupedRowModel = (_table$options$rowMod5 = table.options.rowModels) === null || _table$options$rowMod5 === void 0 || (_table$options$rowMod6 = _table$options$rowMod5.groupedRowModel) === null || _table$options$rowMod6 === void 0 ? void 0 : _table$options$rowMod6.call(_table$options$rowMod5, table);
-	}
-	if (table.options.manualGrouping || !table._rowModels.groupedRowModel) return table.getPreGroupedRowModel();
-	return table._rowModels.groupedRowModel();
-}
-/**
-* Reads the row model immediately before sorting.
-*
-* Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.
-*
-* @example
-* ```ts
-* const rowsBeforeSorting = table_getPreSortedRowModel(table)
-* ```
-*/
-function table_getPreSortedRowModel(table) {
-	return table.getGroupedRowModel();
-}
-/**
-* Resolves the row model after sorting has been applied.
-*
-* When `manualSorting` is enabled, or no sorted row-model factory was
-* registered, this returns the pre-sorted row model because sorted data is
-* expected to be supplied by the caller.
-*
-* @example
-* ```ts
-* const sortedRows = table_getSortedRowModel(table)
-* ```
-*/
-function table_getSortedRowModel(table) {
-	if (!table._rowModels.sortedRowModel) {
-		var _table$options$rowMod7, _table$options$rowMod8;
-		table._rowModels.sortedRowModel = (_table$options$rowMod7 = table.options.rowModels) === null || _table$options$rowMod7 === void 0 || (_table$options$rowMod8 = _table$options$rowMod7.sortedRowModel) === null || _table$options$rowMod8 === void 0 ? void 0 : _table$options$rowMod8.call(_table$options$rowMod7, table);
-	}
-	if (table.options.manualSorting || !table._rowModels.sortedRowModel) return table.getPreSortedRowModel();
-	return table._rowModels.sortedRowModel();
-}
-/**
-* Reads the row model immediately before row expansion.
-*
-* Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.
-*
-* @example
-* ```ts
-* const rowsBeforeExpansion = table_getPreExpandedRowModel(table)
-* ```
-*/
-function table_getPreExpandedRowModel(table) {
-	return table.getSortedRowModel();
-}
-/**
-* Resolves the row model after expanded rows have been flattened into view.
-*
-* When `manualExpanding` is enabled, or no expanded row-model factory was
-* registered, this returns the pre-expanded row model unchanged.
-*
-* @example
-* ```ts
-* const expandedRows = table_getExpandedRowModel(table)
-* ```
-*/
-function table_getExpandedRowModel(table) {
-	if (!table._rowModels.expandedRowModel) {
-		var _table$options$rowMod9, _table$options$rowMod10;
-		table._rowModels.expandedRowModel = (_table$options$rowMod9 = table.options.rowModels) === null || _table$options$rowMod9 === void 0 || (_table$options$rowMod10 = _table$options$rowMod9.expandedRowModel) === null || _table$options$rowMod10 === void 0 ? void 0 : _table$options$rowMod10.call(_table$options$rowMod9, table);
-	}
-	if (table.options.manualExpanding || !table._rowModels.expandedRowModel) return table.getPreExpandedRowModel();
-	return table._rowModels.expandedRowModel();
-}
-/**
-* Reads the row model immediately before pagination.
-*
-* Pagination is the final built-in row-model stage, so this aliases
-* `table.getExpandedRowModel()`.
-*
-* @example
-* ```ts
-* const rowsBeforePagination = table_getPrePaginatedRowModel(table)
-* ```
-*/
-function table_getPrePaginatedRowModel(table) {
-	return table.getExpandedRowModel();
-}
-/**
-* Resolves the row model after pagination has sliced rows for the current page.
-*
-* When `manualPagination` is enabled, or no paginated row-model factory was
-* registered, this returns the pre-paginated row model because pagination is
-* expected to happen before data reaches the table.
-*
-* @example
-* ```ts
-* const pageRows = table_getPaginatedRowModel(table)
-* ```
-*/
-function table_getPaginatedRowModel(table) {
-	if (!table._rowModels.paginatedRowModel) {
-		var _table$options$rowMod11, _table$options$rowMod12;
-		table._rowModels.paginatedRowModel = (_table$options$rowMod11 = table.options.rowModels) === null || _table$options$rowMod11 === void 0 || (_table$options$rowMod12 = _table$options$rowMod11.paginatedRowModel) === null || _table$options$rowMod12 === void 0 ? void 0 : _table$options$rowMod12.call(_table$options$rowMod11, table);
-	}
-	if (table.options.manualPagination || !table._rowModels.paginatedRowModel) return table.getPrePaginatedRowModel();
-	return table._rowModels.paginatedRowModel();
-}
-/**
-* Resolves the final row model consumed by renderers.
-*
-* This is the end of the built-in row-model pipeline: core -> filtering ->
-* grouping -> sorting -> expanding -> pagination.
-*
-* @example
-* ```ts
-* const visibleRows = table_getRowModel(table)
-* ```
-*/
-function table_getRowModel(table) {
-	return table.getPaginatedRowModel();
-}
-
-//#endregion
-exports.table_getCoreRowModel = table_getCoreRowModel;
-exports.table_getExpandedRowModel = table_getExpandedRowModel;
-exports.table_getFilteredRowModel = table_getFilteredRowModel;
-exports.table_getGroupedRowModel = table_getGroupedRowModel;
-exports.table_getPaginatedRowModel = table_getPaginatedRowModel;
-exports.table_getPreExpandedRowModel = table_getPreExpandedRowModel;
-exports.table_getPreFilteredRowModel = table_getPreFilteredRowModel;
-exports.table_getPreGroupedRowModel = table_getPreGroupedRowModel;
-exports.table_getPrePaginatedRowModel = table_getPrePaginatedRowModel;
-exports.table_getPreSortedRowModel = table_getPreSortedRowModel;
-exports.table_getRowModel = table_getRowModel;
-exports.table_getSortedRowModel = table_getSortedRowModel;
-//# sourceMappingURL=coreRowModelsFeature.utils.cjs.map

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

@@ -1 +0,0 @@
-{"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 `options.rowModels.coreRowModel`\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.rowModels?.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.rowModels?.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.rowModels?.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.rowModels?.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.rowModels?.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.rowModels?.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,cAAc;;EAClC,MAAM,WAAW,yCACf,MAAM,QAAQ,2GAAW,0HAAe,KAAK,MAC7CA,8CAAqC,CAAC,CAAC,KAAK;CAChD;CAEA,OAAO,MAAM,WAAW,aAAa;AACvC;;;;;;;;;;;;AAaA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,gBAAgB;AAC/B;;;;;;;;;;;;;AAcA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,6GAAW,+HAAmB,KAAK;CACrD;CAEA,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,iBAAiB;;EACrC,MAAM,WAAW,4CACf,MAAM,QAAQ,6GAAW,8HAAkB,KAAK;CACpD;CAEA,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,gBAAgB;;EACpC,MAAM,WAAW,2CACf,MAAM,QAAQ,6GAAW,6HAAiB,KAAK;CACnD;CAEA,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,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,8GAAW,iIAAmB,KAAK;CACrD;CAEA,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,mBAAmB;;EACvC,MAAM,WAAW,+CACf,MAAM,QAAQ,gHAAW,mIAAoB,KAAK;CACtD;CAEA,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

@@ -1,153 +0,0 @@
-import { RowData } from "../../types/type-utils.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-import { Table_Internal } from "../../types/Table.cjs";
-import { RowModel } from "./coreRowModelsFeature.types.cjs";
-
-//#region src/core/row-models/coreRowModelsFeature.utils.d.ts
-/**
- * Resolves the table's unmodified core row model.
- *
- * The factory is created once per table, either from `options.rowModels.coreRowModel`
- * or the built-in `createCoreRowModel()`, then reused for later calls.
- *
- * @example
- * ```ts
- * const coreRows = table_getCoreRowModel(table)
- * ```
- */
-declare function table_getCoreRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Reads the row model immediately before column/global filtering.
- *
- * Filtering is the first derived row-model stage, so this currently aliases
- * `table.getCoreRowModel()`.
- *
- * @example
- * ```ts
- * const rowsBeforeFiltering = table_getPreFilteredRowModel(table)
- * ```
- */
-declare function table_getPreFilteredRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Resolves the row model after column and global filtering.
- *
- * When `manualFiltering` is enabled, or no filtered row-model factory was
- * registered, this returns the pre-filtered row model because filtering is
- * expected to happen outside the table.
- *
- * @example
- * ```ts
- * const filteredRows = table_getFilteredRowModel(table)
- * ```
- */
-declare function table_getFilteredRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Reads the row model immediately before grouping.
- *
- * Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.
- *
- * @example
- * ```ts
- * const rowsBeforeGrouping = table_getPreGroupedRowModel(table)
- * ```
- */
-declare function table_getPreGroupedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Resolves the row model after grouping has produced grouped and aggregated rows.
- *
- * When `manualGrouping` is enabled, or no grouped row-model factory was
- * registered, this returns the pre-grouped row model unchanged.
- *
- * @example
- * ```ts
- * const groupedRows = table_getGroupedRowModel(table)
- * ```
- */
-declare function table_getGroupedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Reads the row model immediately before sorting.
- *
- * Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.
- *
- * @example
- * ```ts
- * const rowsBeforeSorting = table_getPreSortedRowModel(table)
- * ```
- */
-declare function table_getPreSortedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Resolves the row model after sorting has been applied.
- *
- * When `manualSorting` is enabled, or no sorted row-model factory was
- * registered, this returns the pre-sorted row model because sorted data is
- * expected to be supplied by the caller.
- *
- * @example
- * ```ts
- * const sortedRows = table_getSortedRowModel(table)
- * ```
- */
-declare function table_getSortedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Reads the row model immediately before row expansion.
- *
- * Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.
- *
- * @example
- * ```ts
- * const rowsBeforeExpansion = table_getPreExpandedRowModel(table)
- * ```
- */
-declare function table_getPreExpandedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Resolves the row model after expanded rows have been flattened into view.
- *
- * When `manualExpanding` is enabled, or no expanded row-model factory was
- * registered, this returns the pre-expanded row model unchanged.
- *
- * @example
- * ```ts
- * const expandedRows = table_getExpandedRowModel(table)
- * ```
- */
-declare function table_getExpandedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Reads the row model immediately before pagination.
- *
- * Pagination is the final built-in row-model stage, so this aliases
- * `table.getExpandedRowModel()`.
- *
- * @example
- * ```ts
- * const rowsBeforePagination = table_getPrePaginatedRowModel(table)
- * ```
- */
-declare function table_getPrePaginatedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Resolves the row model after pagination has sliced rows for the current page.
- *
- * When `manualPagination` is enabled, or no paginated row-model factory was
- * registered, this returns the pre-paginated row model because pagination is
- * expected to happen before data reaches the table.
- *
- * @example
- * ```ts
- * const pageRows = table_getPaginatedRowModel(table)
- * ```
- */
-declare function table_getPaginatedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-/**
- * Resolves the final row model consumed by renderers.
- *
- * This is the end of the built-in row-model pipeline: core -> filtering ->
- * grouping -> sorting -> expanding -> pagination.
- *
- * @example
- * ```ts
- * const visibleRows = table_getRowModel(table)
- * ```
- */
-declare function table_getRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
-//#endregion
-export { table_getCoreRowModel, table_getExpandedRowModel, table_getFilteredRowModel, table_getGroupedRowModel, table_getPaginatedRowModel, table_getPreExpandedRowModel, table_getPreFilteredRowModel, table_getPreGroupedRowModel, table_getPrePaginatedRowModel, table_getPreSortedRowModel, table_getRowModel, table_getSortedRowModel };
-//# sourceMappingURL=coreRowModelsFeature.utils.d.cts.map

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

@@ -1 +0,0 @@
-{"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 `options.rowModels.coreRowModel`\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.rowModels?.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.rowModels?.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.rowModels?.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.rowModels?.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.rowModels?.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.rowModels?.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,cAAc;;EAClC,MAAM,WAAW,yCACf,MAAM,QAAQ,2GAAW,0HAAe,KAAK,MAC7C,mBAAqC,CAAC,CAAC,KAAK;CAChD;CAEA,OAAO,MAAM,WAAW,aAAa;AACvC;;;;;;;;;;;;AAaA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,gBAAgB;AAC/B;;;;;;;;;;;;;AAcA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,6GAAW,+HAAmB,KAAK;CACrD;CAEA,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,iBAAiB;;EACrC,MAAM,WAAW,4CACf,MAAM,QAAQ,6GAAW,8HAAkB,KAAK;CACpD;CAEA,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,gBAAgB;;EACpC,MAAM,WAAW,2CACf,MAAM,QAAQ,6GAAW,6HAAiB,KAAK;CACnD;CAEA,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,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,8GAAW,iIAAmB,KAAK;CACrD;CAEA,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,mBAAmB;;EACvC,MAAM,WAAW,+CACf,MAAM,QAAQ,gHAAW,mIAAoB,KAAK;CACtD;CAEA,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/createCoreRowModel.cjs

@@ -1,52 +0,0 @@
-const require_utils = require('../../utils.cjs');
-const require_constructRow = require('../rows/constructRow.cjs');
-const require_rowPaginationFeature_utils = require('../../features/row-pagination/rowPaginationFeature.utils.cjs');
-
-//#region src/core/row-models/createCoreRowModel.ts
-/**
-* Creates a memoized core row model factory.
-*
-* The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
-*/
-function createCoreRowModel() {
-	return (_table) => {
-		const table = _table;
-		return require_utils.tableMemo({
-			feature: "coreRowModelsFeature",
-			table,
-			fnName: "table.getCoreRowModel",
-			memoDeps: () => [table.options.data],
-			fn: () => _createCoreRowModel(table, table.options.data),
-			onAfterUpdate: () => require_rowPaginationFeature_utils.table_autoResetPageIndex(table)
-		});
-	};
-}
-function _createCoreRowModel(table, data) {
-	const rowModel = {
-		rows: [],
-		flatRows: [],
-		rowsById: {}
-	};
-	const accessRows = (originalRows, depth = 0, parentRow) => {
-		const rows = [];
-		for (let i = 0; i < originalRows.length; i++) {
-			const originalRow = originalRows[i];
-			const row = require_constructRow.constructRow(table, table.getRowId(originalRow, i, parentRow), originalRow, i, depth, void 0, parentRow === null || parentRow === void 0 ? void 0 : parentRow.id);
-			rowModel.flatRows.push(row);
-			rowModel.rowsById[row.id] = row;
-			rows.push(row);
-			if (table.options.getSubRows) {
-				var _row$originalSubRows;
-				row.originalSubRows = table.options.getSubRows(originalRow, i);
-				if ((_row$originalSubRows = row.originalSubRows) === null || _row$originalSubRows === void 0 ? void 0 : _row$originalSubRows.length) row.subRows = accessRows(row.originalSubRows, depth + 1, row);
-			}
-		}
-		return rows;
-	};
-	rowModel.rows = accessRows(data);
-	return rowModel;
-}
-
-//#endregion
-exports.createCoreRowModel = createCoreRowModel;
-//# sourceMappingURL=createCoreRowModel.cjs.map

package/dist/core/row-models/createCoreRowModel.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createCoreRowModel.cjs","names":["tableMemo","table_autoResetPageIndex","constructRow"],"sources":["../../../src/core/row-models/createCoreRowModel.ts"],"sourcesContent":["import { constructRow } from '../rows/constructRow'\nimport { tableMemo } from '../../utils'\nimport { table_autoResetPageIndex } from '../../features/row-pagination/rowPaginationFeature.utils'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { RowModel } from './coreRowModelsFeature.types'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { RowData } from '../../types/type-utils'\n\n/**\n * Creates a memoized core row model factory.\n *\n * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.\n */\nexport function createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {\n  return (_table) => {\n    const table = _table as unknown as Table_Internal<TFeatures, TData>\n    return tableMemo({\n      feature: 'coreRowModelsFeature',\n      table,\n      fnName: 'table.getCoreRowModel',\n      memoDeps: () => [table.options.data],\n      fn: () => _createCoreRowModel(table, table.options.data),\n      onAfterUpdate: () => table_autoResetPageIndex(table),\n    })\n  }\n}\n\nfunction _createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  data: ReadonlyArray<TData>,\n): {\n  rows: Array<Row<TFeatures, TData>>\n  flatRows: Array<Row<TFeatures, TData>>\n  rowsById: Record<string, Row<TFeatures, TData>>\n} {\n  const rowModel: RowModel<TFeatures, TData> = {\n    rows: [],\n    flatRows: [],\n    rowsById: {},\n  }\n\n  const accessRows = (\n    originalRows: ReadonlyArray<TData>,\n    depth = 0,\n    parentRow?: Row<TFeatures, TData>,\n  ): Array<Row<TFeatures, TData>> => {\n    const rows = [] as Array<Row<TFeatures, TData>>\n\n    for (let i = 0; i < originalRows.length; i++) {\n      const originalRow = originalRows[i]!\n      // Make the row\n      const row = constructRow(\n        table,\n        table.getRowId(originalRow, i, parentRow),\n        originalRow,\n        i,\n        depth,\n        undefined,\n        parentRow?.id,\n      )\n\n      // Keep track of every row in a flat array\n      rowModel.flatRows.push(row)\n      // Also keep track of every row by its ID\n      rowModel.rowsById[row.id] = row\n      // Push table row into parent\n      rows.push(row)\n\n      // Get the original subrows\n      if (table.options.getSubRows) {\n        row.originalSubRows = table.options.getSubRows(originalRow, i)\n\n        // Then recursively access them\n        if (row.originalSubRows?.length) {\n          row.subRows = accessRows(row.originalSubRows, depth + 1, row)\n        }\n      }\n    }\n\n    return rows\n  }\n\n  rowModel.rows = accessRows(data)\n\n  return rowModel\n}\n"],"mappings":";;;;;;;;;;AAcA,SAAgB,qBAG0D;CACxE,QAAQ,WAAW;EACjB,MAAM,QAAQ;EACd,OAAOA,wBAAU;GACf,SAAS;GACT;GACA,QAAQ;GACR,gBAAgB,CAAC,MAAM,QAAQ,IAAI;GACnC,UAAU,oBAAoB,OAAO,MAAM,QAAQ,IAAI;GACvD,qBAAqBC,4DAAyB,KAAK;EACrD,CAAC;CACH;AACF;AAEA,SAAS,oBAIP,OACA,MAKA;CACA,MAAM,WAAuC;EAC3C,MAAM,CAAC;EACP,UAAU,CAAC;EACX,UAAU,CAAC;CACb;CAEA,MAAM,cACJ,cACA,QAAQ,GACR,cACiC;EACjC,MAAM,OAAO,CAAC;EAEd,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;GAC5C,MAAM,cAAc,aAAa;GAEjC,MAAM,MAAMC,kCACV,OACA,MAAM,SAAS,aAAa,GAAG,SAAS,GACxC,aACA,GACA,OACA,8DACA,UAAW,EACb;GAGA,SAAS,SAAS,KAAK,GAAG;GAE1B,SAAS,SAAS,IAAI,MAAM;GAE5B,KAAK,KAAK,GAAG;GAGb,IAAI,MAAM,QAAQ,YAAY;;IAC5B,IAAI,kBAAkB,MAAM,QAAQ,WAAW,aAAa,CAAC;IAG7D,4BAAI,IAAI,6FAAiB,QACvB,IAAI,UAAU,WAAW,IAAI,iBAAiB,QAAQ,GAAG,GAAG;GAEhE;EACF;EAEA,OAAO;CACT;CAEA,SAAS,OAAO,WAAW,IAAI;CAE/B,OAAO;AACT"}

package/dist/core/row-models/createCoreRowModel.d.cts

@@ -1,15 +0,0 @@
-import { RowData } from "../../types/type-utils.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-import { Table } from "../../types/Table.cjs";
-import { RowModel } from "./coreRowModelsFeature.types.cjs";
-
-//#region src/core/row-models/createCoreRowModel.d.ts
-/**
- * Creates a memoized core row model factory.
- *
- * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
- */
-declare function createCoreRowModel<TFeatures extends TableFeatures, TData extends RowData>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
-//#endregion
-export { createCoreRowModel };
-//# sourceMappingURL=createCoreRowModel.d.cts.map

package/dist/core/row-models/createCoreRowModel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createCoreRowModel.js","names":[],"sources":["../../../src/core/row-models/createCoreRowModel.ts"],"sourcesContent":["import { constructRow } from '../rows/constructRow'\nimport { tableMemo } from '../../utils'\nimport { table_autoResetPageIndex } from '../../features/row-pagination/rowPaginationFeature.utils'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { RowModel } from './coreRowModelsFeature.types'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { RowData } from '../../types/type-utils'\n\n/**\n * Creates a memoized core row model factory.\n *\n * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.\n */\nexport function createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {\n  return (_table) => {\n    const table = _table as unknown as Table_Internal<TFeatures, TData>\n    return tableMemo({\n      feature: 'coreRowModelsFeature',\n      table,\n      fnName: 'table.getCoreRowModel',\n      memoDeps: () => [table.options.data],\n      fn: () => _createCoreRowModel(table, table.options.data),\n      onAfterUpdate: () => table_autoResetPageIndex(table),\n    })\n  }\n}\n\nfunction _createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  data: ReadonlyArray<TData>,\n): {\n  rows: Array<Row<TFeatures, TData>>\n  flatRows: Array<Row<TFeatures, TData>>\n  rowsById: Record<string, Row<TFeatures, TData>>\n} {\n  const rowModel: RowModel<TFeatures, TData> = {\n    rows: [],\n    flatRows: [],\n    rowsById: {},\n  }\n\n  const accessRows = (\n    originalRows: ReadonlyArray<TData>,\n    depth = 0,\n    parentRow?: Row<TFeatures, TData>,\n  ): Array<Row<TFeatures, TData>> => {\n    const rows = [] as Array<Row<TFeatures, TData>>\n\n    for (let i = 0; i < originalRows.length; i++) {\n      const originalRow = originalRows[i]!\n      // Make the row\n      const row = constructRow(\n        table,\n        table.getRowId(originalRow, i, parentRow),\n        originalRow,\n        i,\n        depth,\n        undefined,\n        parentRow?.id,\n      )\n\n      // Keep track of every row in a flat array\n      rowModel.flatRows.push(row)\n      // Also keep track of every row by its ID\n      rowModel.rowsById[row.id] = row\n      // Push table row into parent\n      rows.push(row)\n\n      // Get the original subrows\n      if (table.options.getSubRows) {\n        row.originalSubRows = table.options.getSubRows(originalRow, i)\n\n        // Then recursively access them\n        if (row.originalSubRows?.length) {\n          row.subRows = accessRows(row.originalSubRows, depth + 1, row)\n        }\n      }\n    }\n\n    return rows\n  }\n\n  rowModel.rows = accessRows(data)\n\n  return rowModel\n}\n"],"mappings":";;;;;;;;;;AAcA,SAAgB,qBAG0D;CACxE,QAAQ,WAAW;EACjB,MAAM,QAAQ;EACd,OAAO,UAAU;GACf,SAAS;GACT;GACA,QAAQ;GACR,gBAAgB,CAAC,MAAM,QAAQ,IAAI;GACnC,UAAU,oBAAoB,OAAO,MAAM,QAAQ,IAAI;GACvD,qBAAqB,yBAAyB,KAAK;EACrD,CAAC;CACH;AACF;AAEA,SAAS,oBAIP,OACA,MAKA;CACA,MAAM,WAAuC;EAC3C,MAAM,CAAC;EACP,UAAU,CAAC;EACX,UAAU,CAAC;CACb;CAEA,MAAM,cACJ,cACA,QAAQ,GACR,cACiC;EACjC,MAAM,OAAO,CAAC;EAEd,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;GAC5C,MAAM,cAAc,aAAa;GAEjC,MAAM,MAAM,aACV,OACA,MAAM,SAAS,aAAa,GAAG,SAAS,GACxC,aACA,GACA,OACA,8DACA,UAAW,EACb;GAGA,SAAS,SAAS,KAAK,GAAG;GAE1B,SAAS,SAAS,IAAI,MAAM;GAE5B,KAAK,KAAK,GAAG;GAGb,IAAI,MAAM,QAAQ,YAAY;;IAC5B,IAAI,kBAAkB,MAAM,QAAQ,WAAW,aAAa,CAAC;IAG7D,4BAAI,IAAI,6FAAiB,QACvB,IAAI,UAAU,WAAW,IAAI,iBAAiB,QAAQ,GAAG,GAAG;GAEhE;EACF;EAEA,OAAO;CACT;CAEA,SAAS,OAAO,WAAW,IAAI;CAE/B,OAAO;AACT"}

package/dist/core/rows/constructRow.cjs

@@ -1,44 +0,0 @@
-
-//#region src/core/rows/constructRow.ts
-/**
-* Creates or retrieves the row prototype for a table.
-* The prototype is cached on the table and shared by all row instances.
-*/
-function getRowPrototype(table) {
-	if (!table._rowPrototype) {
-		table._rowPrototype = { table };
-		const features = Object.values(table._features);
-		for (let i = 0; i < features.length; i++) {
-			var _assignRowPrototype, _ref;
-			(_assignRowPrototype = (_ref = features[i]).assignRowPrototype) === null || _assignRowPrototype === void 0 || _assignRowPrototype.call(_ref, table._rowPrototype, table);
-		}
-	}
-	return table._rowPrototype;
-}
-/**
-* Constructs a row instance from normalized table internals.
-*
-* This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.
-*/
-const constructRow = (table, id, original, rowIndex, depth, subRows, parentId) => {
-	const rowPrototype = getRowPrototype(table);
-	const row = Object.create(rowPrototype);
-	row._uniqueValuesCache = {};
-	row._valuesCache = {};
-	row.depth = depth;
-	row.id = id;
-	row.index = rowIndex;
-	row.original = original;
-	row.parentId = parentId;
-	row.subRows = subRows ?? [];
-	const features = Object.values(table._features);
-	for (let i = 0; i < features.length; i++) {
-		var _initRowInstanceData, _ref2;
-		(_initRowInstanceData = (_ref2 = features[i]).initRowInstanceData) === null || _initRowInstanceData === void 0 || _initRowInstanceData.call(_ref2, row);
-	}
-	return row;
-};
-
-//#endregion
-exports.constructRow = constructRow;
-//# sourceMappingURL=constructRow.cjs.map

package/dist/core/rows/constructRow.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"constructRow.cjs","names":[],"sources":["../../../src/core/rows/constructRow.ts"],"sourcesContent":["import type { Table_Internal } from '../../types/Table'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Row_CoreProperties } from './coreRowsFeature.types'\n\n/**\n * Creates or retrieves the row prototype for a table.\n * The prototype is cached on the table and shared by all row instances.\n */\nfunction getRowPrototype<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): object {\n  if (!table._rowPrototype) {\n    table._rowPrototype = { table }\n    const features = Object.values(table._features)\n    for (let i = 0; i < features.length; i++) {\n      features[i]!.assignRowPrototype?.(table._rowPrototype, table)\n    }\n  }\n  return table._rowPrototype\n}\n\n/**\n * Constructs a row instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport const constructRow = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  id: string,\n  original: TData,\n  rowIndex: number,\n  depth: number,\n  subRows?: Array<Row<TFeatures, TData>>,\n  parentId?: string,\n): Row<TFeatures, TData> => {\n  // Create row with shared prototype for memory efficiency\n  const rowPrototype = getRowPrototype(table)\n  const row = Object.create(rowPrototype) as Row_CoreProperties<\n    TFeatures,\n    TData\n  >\n\n  // Only assign instance-specific properties\n  row._uniqueValuesCache = {}\n  row._valuesCache = {}\n  row.depth = depth\n  row.id = id\n  row.index = rowIndex\n  row.original = original\n  row.parentId = parentId\n  row.subRows = subRows ?? []\n\n  // Initialize instance-specific data (e.g., caches) for features that need it\n  const features = Object.values(table._features)\n  for (let i = 0; i < features.length; i++) {\n    features[i]!.initRowInstanceData?.(row)\n  }\n\n  return row as Row<TFeatures, TData>\n}\n"],"mappings":";;;;;;AAUA,SAAS,gBAGP,OAAiD;CACjD,IAAI,CAAC,MAAM,eAAe;EACxB,MAAM,gBAAgB,EAAE,MAAM;EAC9B,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;EAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;GACxC,wCAAS,IAAI,iGAAqB,MAAM,eAAe,KAAK;EAC9D;CACF;CACA,OAAO,MAAM;AACf;;;;;;AAOA,MAAa,gBAIX,OACA,IACA,UACA,UACA,OACA,SACA,aAC0B;CAE1B,MAAM,eAAe,gBAAgB,KAAK;CAC1C,MAAM,MAAM,OAAO,OAAO,YAAY;CAMtC,IAAI,qBAAqB,CAAC;CAC1B,IAAI,eAAe,CAAC;CACpB,IAAI,QAAQ;CACZ,IAAI,KAAK;CACT,IAAI,QAAQ;CACZ,IAAI,WAAW;CACf,IAAI,WAAW;CACf,IAAI,UAAU,WAAW,CAAC;CAG1B,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;CAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;EACxC,0CAAS,IAAI,qGAAsB,GAAG;CACxC;CAEA,OAAO;AACT"}

package/dist/core/rows/constructRow.d.cts

@@ -1,15 +0,0 @@
-import { RowData } from "../../types/type-utils.cjs";
-import { Row } from "../../types/Row.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-import { Table_Internal } from "../../types/Table.cjs";
-
-//#region src/core/rows/constructRow.d.ts
-/**
- * Constructs a row instance from normalized table internals.
- *
- * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.
- */
-declare const constructRow: <TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, id: string, original: TData, rowIndex: number, depth: number, subRows?: Array<Row<TFeatures, TData>>, parentId?: string) => Row<TFeatures, TData>;
-//#endregion
-export { constructRow };
-//# sourceMappingURL=constructRow.d.cts.map

package/dist/core/rows/constructRow.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constructRow.js","names":[],"sources":["../../../src/core/rows/constructRow.ts"],"sourcesContent":["import type { Table_Internal } from '../../types/Table'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Row_CoreProperties } from './coreRowsFeature.types'\n\n/**\n * Creates or retrieves the row prototype for a table.\n * The prototype is cached on the table and shared by all row instances.\n */\nfunction getRowPrototype<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): object {\n  if (!table._rowPrototype) {\n    table._rowPrototype = { table }\n    const features = Object.values(table._features)\n    for (let i = 0; i < features.length; i++) {\n      features[i]!.assignRowPrototype?.(table._rowPrototype, table)\n    }\n  }\n  return table._rowPrototype\n}\n\n/**\n * Constructs a row instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport const constructRow = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  id: string,\n  original: TData,\n  rowIndex: number,\n  depth: number,\n  subRows?: Array<Row<TFeatures, TData>>,\n  parentId?: string,\n): Row<TFeatures, TData> => {\n  // Create row with shared prototype for memory efficiency\n  const rowPrototype = getRowPrototype(table)\n  const row = Object.create(rowPrototype) as Row_CoreProperties<\n    TFeatures,\n    TData\n  >\n\n  // Only assign instance-specific properties\n  row._uniqueValuesCache = {}\n  row._valuesCache = {}\n  row.depth = depth\n  row.id = id\n  row.index = rowIndex\n  row.original = original\n  row.parentId = parentId\n  row.subRows = subRows ?? []\n\n  // Initialize instance-specific data (e.g., caches) for features that need it\n  const features = Object.values(table._features)\n  for (let i = 0; i < features.length; i++) {\n    features[i]!.initRowInstanceData?.(row)\n  }\n\n  return row as Row<TFeatures, TData>\n}\n"],"mappings":";;;;;AAUA,SAAS,gBAGP,OAAiD;CACjD,IAAI,CAAC,MAAM,eAAe;EACxB,MAAM,gBAAgB,EAAE,MAAM;EAC9B,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;EAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;GACxC,wCAAS,IAAI,iGAAqB,MAAM,eAAe,KAAK;EAC9D;CACF;CACA,OAAO,MAAM;AACf;;;;;;AAOA,MAAa,gBAIX,OACA,IACA,UACA,UACA,OACA,SACA,aAC0B;CAE1B,MAAM,eAAe,gBAAgB,KAAK;CAC1C,MAAM,MAAM,OAAO,OAAO,YAAY;CAMtC,IAAI,qBAAqB,CAAC;CAC1B,IAAI,eAAe,CAAC;CACpB,IAAI,QAAQ;CACZ,IAAI,KAAK;CACT,IAAI,QAAQ;CACZ,IAAI,WAAW;CACf,IAAI,WAAW;CACf,IAAI,UAAU,WAAW,CAAC;CAG1B,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;CAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;EACxC,0CAAS,IAAI,qGAAsB,GAAG;CACxC;CAEA,OAAO;AACT"}