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

package/dist/features/row-pagination/rowPaginationFeature.utils.cjs

@@ -1,312 +0,0 @@
-const require_utils = require('../../utils.cjs');
-
-//#region src/features/row-pagination/rowPaginationFeature.utils.ts
-const defaultPageIndex = 0;
-const defaultPageSize = 10;
-/**
-* Creates the default pagination state used by the pagination feature.
-*
-* The feature default starts at the first page with a page size of 10. Reset
-* APIs use this value when `defaultState` is `true`.
-*
-* @example
-* ```ts
-* const pagination = getDefaultPaginationState()
-* ```
-*/
-function getDefaultPaginationState() {
-	return {
-		pageIndex: defaultPageIndex,
-		pageSize: defaultPageSize
-	};
-}
-/**
-* Resets the page index when a page-altering change should return to page 0.
-*
-* The reset runs when `autoResetAll`, `autoResetPageIndex`, or the default
-* client-side pagination behavior allows it. Manual pagination opts out unless
-* the reset options explicitly opt back in.
-*
-* @example
-* ```ts
-* table_autoResetPageIndex(table)
-* ```
-*/
-function table_autoResetPageIndex(table) {
-	if (table.options.autoResetAll ?? table.options.autoResetPageIndex ?? !table.options.manualPagination) table_resetPageIndex(table);
-}
-/**
-* Routes a pagination updater through the table's pagination change handler.
-*
-* The updater may be a next state object or a function of the previous
-* `PaginationState`; controlled state and external atoms observe the same
-* updater path as the instance API.
-*
-* @example
-* ```ts
-* table_setPagination(table, (old) => old)
-* ```
-*/
-function table_setPagination(table, updater) {
-	var _table$options$onPagi, _table$options;
-	const safeUpdater = (old) => {
-		return require_utils.functionalUpdate(updater, old);
-	};
-	return (_table$options$onPagi = (_table$options = table.options).onPaginationChange) === null || _table$options$onPagi === void 0 ? void 0 : _table$options$onPagi.call(_table$options, safeUpdater);
-}
-/**
-* Resets `pagination` to the configured initial state or feature default.
-*
-* With no argument, the reset clones `table.initialState.pagination` when it
-* exists. Passing `true` ignores initial state and resets to
-* `{ pageIndex: 0, pageSize: 10 }`.
-*
-* @example
-* ```ts
-* table_resetPagination(table)
-* table_resetPagination(table, true)
-* ```
-*/
-function table_resetPagination(table, defaultState) {
-	table_setPagination(table, defaultState ? getDefaultPaginationState() : require_utils.cloneState(table.initialState.pagination ?? getDefaultPaginationState()));
-}
-/**
-* Updates `pagination.pageIndex` and clamps it to the known page range.
-*
-* Unknown page counts (`undefined` or `-1`) allow any non-negative page index.
-* Known page counts clamp the index between `0` and `pageCount - 1`.
-*
-* @example
-* ```ts
-* table_setPageIndex(table, (old) => old)
-* ```
-*/
-function table_setPageIndex(table, updater) {
-	table_setPagination(table, (old) => {
-		let pageIndex = require_utils.functionalUpdate(updater, old.pageIndex);
-		const maxPageIndex = typeof table.options.pageCount === "undefined" || table.options.pageCount === -1 ? Number.MAX_SAFE_INTEGER : table.options.pageCount - 1;
-		pageIndex = Math.max(0, Math.min(pageIndex, maxPageIndex));
-		return {
-			...old,
-			pageIndex
-		};
-	});
-}
-/**
-* Resets only `pagination.pageIndex`.
-*
-* With no argument, the reset uses `table.initialState.pagination?.pageIndex`
-* or `0`. Passing `true` always resets the page index to `0`.
-*
-* @example
-* ```ts
-* table_resetPageIndex(table)
-* table_resetPageIndex(table, true)
-* ```
-*/
-function table_resetPageIndex(table, defaultState) {
-	var _table$atoms$paginati, _table$initialState$p;
-	const currentPageIndex = ((_table$atoms$paginati = table.atoms.pagination) === null || _table$atoms$paginati === void 0 || (_table$atoms$paginati = _table$atoms$paginati.get()) === null || _table$atoms$paginati === void 0 ? void 0 : _table$atoms$paginati.pageIndex) ?? defaultPageIndex;
-	const newPageIndex = defaultState ? defaultPageIndex : ((_table$initialState$p = table.initialState.pagination) === null || _table$initialState$p === void 0 ? void 0 : _table$initialState$p.pageIndex) ?? defaultPageIndex;
-	if (newPageIndex === currentPageIndex) return;
-	table_setPageIndex(table, newPageIndex);
-}
-/**
-* Resets only `pagination.pageSize`.
-*
-* With no argument, the reset uses `table.initialState.pagination?.pageSize`
-* or `10`. Passing `true` always resets the page size to `10`.
-*
-* @example
-* ```ts
-* table_resetPageSize(table)
-* table_resetPageSize(table, true)
-* ```
-*/
-function table_resetPageSize(table, defaultState) {
-	var _table$atoms$paginati2, _table$initialState$p2;
-	const currentPageSize = ((_table$atoms$paginati2 = table.atoms.pagination) === null || _table$atoms$paginati2 === void 0 || (_table$atoms$paginati2 = _table$atoms$paginati2.get()) === null || _table$atoms$paginati2 === void 0 ? void 0 : _table$atoms$paginati2.pageSize) ?? defaultPageSize;
-	const newPageSize = defaultState ? defaultPageSize : ((_table$initialState$p2 = table.initialState.pagination) === null || _table$initialState$p2 === void 0 ? void 0 : _table$initialState$p2.pageSize) ?? defaultPageSize;
-	if (newPageSize === currentPageSize) return;
-	table_setPageSize(table, newPageSize);
-}
-/**
-* Updates `pagination.pageSize` while preserving the current top row.
-*
-* The new size is clamped to at least `1`, and `pageIndex` is recalculated so
-* the row that was previously at the top of the page remains in view.
-*
-* @example
-* ```ts
-* table_setPageSize(table, (old) => old)
-* ```
-*/
-function table_setPageSize(table, updater) {
-	table_setPagination(table, (old) => {
-		const pageSize = Math.max(1, require_utils.functionalUpdate(updater, old.pageSize));
-		const topRowIndex = old.pageSize * old.pageIndex;
-		const pageIndex = Math.floor(topRowIndex / pageSize);
-		return {
-			...old,
-			pageIndex,
-			pageSize
-		};
-	});
-}
-/**
-* Builds the zero-based page indexes available for the current page count.
-*
-* Unknown or empty page counts return an empty array; otherwise the result is
-* `[0, 1, ...pageCount - 1]`.
-*
-* @example
-* ```ts
-* const pageIndexes = table_getPageOptions(table)
-* ```
-*/
-function table_getPageOptions(table) {
-	const pageCount = table_getPageCount(table);
-	let pageOptions = [];
-	if (pageCount && pageCount > 0) pageOptions = [...new Array(pageCount)].fill(null).map((_, i) => i);
-	return pageOptions;
-}
-/**
-* Checks whether the current page index can move backward.
-*
-* The first page is page index `0`, so only positive page indexes can navigate
-* to a previous page.
-*
-* @example
-* ```ts
-* const canGoBack = table_getCanPreviousPage(table)
-* ```
-*/
-function table_getCanPreviousPage(table) {
-	var _table$atoms$paginati3;
-	return (((_table$atoms$paginati3 = table.atoms.pagination) === null || _table$atoms$paginati3 === void 0 || (_table$atoms$paginati3 = _table$atoms$paginati3.get()) === null || _table$atoms$paginati3 === void 0 ? void 0 : _table$atoms$paginati3.pageIndex) ?? 0) > 0;
-}
-/**
-* Checks whether the current page index can move forward.
-*
-* A `pageCount` of `-1` means the caller does not know the total page count, so
-* this returns `true`. A page count of `0` returns `false`.
-*
-* @example
-* ```ts
-* const canGoForward = table_getCanNextPage(table)
-* ```
-*/
-function table_getCanNextPage(table) {
-	var _table$atoms$paginati4;
-	const pageIndex = ((_table$atoms$paginati4 = table.atoms.pagination) === null || _table$atoms$paginati4 === void 0 || (_table$atoms$paginati4 = _table$atoms$paginati4.get()) === null || _table$atoms$paginati4 === void 0 ? void 0 : _table$atoms$paginati4.pageIndex) ?? defaultPageIndex;
-	const pageCount = table_getPageCount(table);
-	if (pageCount === -1) return true;
-	if (pageCount === 0) return false;
-	return pageIndex < pageCount - 1;
-}
-/**
-* Moves the table to the previous page.
-*
-* This delegates to `table_setPageIndex` so pagination state ownership and
-* updater semantics remain consistent.
-*
-* @example
-* ```ts
-* table_previousPage(table)
-* ```
-*/
-function table_previousPage(table) {
-	return table_setPageIndex(table, (old) => old - 1);
-}
-/**
-* Moves the table to the next page.
-*
-* This delegates to `table_setPageIndex` so pagination state ownership and
-* updater semantics remain consistent.
-*
-* @example
-* ```ts
-* table_nextPage(table)
-* ```
-*/
-function table_nextPage(table) {
-	return table_setPageIndex(table, (old) => {
-		return old + 1;
-	});
-}
-/**
-* Moves the table to the first page.
-*
-* This is a convenience wrapper around `table_setPageIndex(table, 0)`.
-*
-* @example
-* ```ts
-* table_firstPage(table)
-* ```
-*/
-function table_firstPage(table) {
-	return table_setPageIndex(table, 0);
-}
-/**
-* Moves the table to the last known page.
-*
-* The target page is derived from `table_getPageCount(table) - 1`.
-*
-* @example
-* ```ts
-* table_lastPage(table)
-* ```
-*/
-function table_lastPage(table) {
-	return table_setPageIndex(table, table_getPageCount(table) - 1);
-}
-/**
-* Resolves the number of pages for the current pagination state.
-*
-* `options.pageCount` wins for manual pagination. Otherwise the value is
-* calculated from `table_getRowCount(table)` and the current `pageSize`.
-*
-* @example
-* ```ts
-* const pages = table_getPageCount(table)
-* ```
-*/
-function table_getPageCount(table) {
-	var _table$atoms$paginati5;
-	return table.options.pageCount ?? Math.ceil(table_getRowCount(table) / (((_table$atoms$paginati5 = table.atoms.pagination) === null || _table$atoms$paginati5 === void 0 || (_table$atoms$paginati5 = _table$atoms$paginati5.get()) === null || _table$atoms$paginati5 === void 0 ? void 0 : _table$atoms$paginati5.pageSize) ?? defaultPageSize));
-}
-/**
-* Resolves the total row count used for pagination math.
-*
-* `options.rowCount` wins for manual pagination. Otherwise the count comes
-* from the pre-paginated row model so filtering, grouping, sorting, and
-* expansion are reflected before the page slice is applied.
-*
-* @example
-* ```ts
-* const rows = table_getRowCount(table)
-* ```
-*/
-function table_getRowCount(table) {
-	return table.options.rowCount ?? table.getPrePaginatedRowModel().rows.length;
-}
-
-//#endregion
-exports.getDefaultPaginationState = getDefaultPaginationState;
-exports.table_autoResetPageIndex = table_autoResetPageIndex;
-exports.table_firstPage = table_firstPage;
-exports.table_getCanNextPage = table_getCanNextPage;
-exports.table_getCanPreviousPage = table_getCanPreviousPage;
-exports.table_getPageCount = table_getPageCount;
-exports.table_getPageOptions = table_getPageOptions;
-exports.table_getRowCount = table_getRowCount;
-exports.table_lastPage = table_lastPage;
-exports.table_nextPage = table_nextPage;
-exports.table_previousPage = table_previousPage;
-exports.table_resetPageIndex = table_resetPageIndex;
-exports.table_resetPageSize = table_resetPageSize;
-exports.table_resetPagination = table_resetPagination;
-exports.table_setPageIndex = table_setPageIndex;
-exports.table_setPageSize = table_setPageSize;
-exports.table_setPagination = table_setPagination;
-//# sourceMappingURL=rowPaginationFeature.utils.cjs.map

package/dist/features/row-pagination/rowPaginationFeature.utils.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"rowPaginationFeature.utils.cjs","names":["functionalUpdate","cloneState"],"sources":["../../../src/features/row-pagination/rowPaginationFeature.utils.ts"],"sourcesContent":["import { cloneState, functionalUpdate } from '../../utils'\nimport type { RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { PaginationState } from './rowPaginationFeature.types'\n\nconst defaultPageIndex = 0\nconst defaultPageSize = 10\n\n/**\n * Creates the default pagination state used by the pagination feature.\n *\n * The feature default starts at the first page with a page size of 10. Reset\n * APIs use this value when `defaultState` is `true`.\n *\n * @example\n * ```ts\n * const pagination = getDefaultPaginationState()\n * ```\n */\nexport function getDefaultPaginationState(): PaginationState {\n  return {\n    pageIndex: defaultPageIndex,\n    pageSize: defaultPageSize,\n  }\n}\n\n/**\n * Resets the page index when a page-altering change should return to page 0.\n *\n * The reset runs when `autoResetAll`, `autoResetPageIndex`, or the default\n * client-side pagination behavior allows it. Manual pagination opts out unless\n * the reset options explicitly opt back in.\n *\n * @example\n * ```ts\n * table_autoResetPageIndex(table)\n * ```\n */\nexport function table_autoResetPageIndex<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  if (\n    table.options.autoResetAll ??\n    table.options.autoResetPageIndex ??\n    !table.options.manualPagination\n  ) {\n    table_resetPageIndex(table)\n  }\n}\n\n/**\n * Routes a pagination updater through the table's pagination change handler.\n *\n * The updater may be a next state object or a function of the previous\n * `PaginationState`; controlled state and external atoms observe the same\n * updater path as the instance API.\n *\n * @example\n * ```ts\n * table_setPagination(table, (old) => old)\n * ```\n */\nexport function table_setPagination<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: Updater<PaginationState>) {\n  const safeUpdater: Updater<PaginationState> = (old) => {\n    const newState = functionalUpdate(updater, old)\n\n    return newState\n  }\n\n  return table.options.onPaginationChange?.(safeUpdater)\n}\n\n/**\n * Resets `pagination` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.pagination` when it\n * exists. Passing `true` ignores initial state and resets to\n * `{ pageIndex: 0, pageSize: 10 }`.\n *\n * @example\n * ```ts\n * table_resetPagination(table)\n * table_resetPagination(table, true)\n * ```\n */\nexport function table_resetPagination<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setPagination(\n    table,\n    defaultState\n      ? getDefaultPaginationState()\n      : cloneState(\n          table.initialState.pagination ?? getDefaultPaginationState(),\n        ),\n  )\n}\n\n/**\n * Updates `pagination.pageIndex` and clamps it to the known page range.\n *\n * Unknown page counts (`undefined` or `-1`) allow any non-negative page index.\n * Known page counts clamp the index between `0` and `pageCount - 1`.\n *\n * @example\n * ```ts\n * table_setPageIndex(table, (old) => old)\n * ```\n */\nexport function table_setPageIndex<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: Updater<number>) {\n  table_setPagination(table, (old) => {\n    let pageIndex = functionalUpdate(updater, old.pageIndex)\n\n    const maxPageIndex =\n      typeof table.options.pageCount === 'undefined' ||\n      table.options.pageCount === -1\n        ? Number.MAX_SAFE_INTEGER\n        : table.options.pageCount - 1\n\n    pageIndex = Math.max(0, Math.min(pageIndex, maxPageIndex))\n\n    return {\n      ...old,\n      pageIndex,\n    }\n  })\n}\n\n/**\n * Resets only `pagination.pageIndex`.\n *\n * With no argument, the reset uses `table.initialState.pagination?.pageIndex`\n * or `0`. Passing `true` always resets the page index to `0`.\n *\n * @example\n * ```ts\n * table_resetPageIndex(table)\n * table_resetPageIndex(table, true)\n * ```\n */\nexport function table_resetPageIndex<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  const currentPageIndex =\n    table.atoms.pagination?.get()?.pageIndex ?? defaultPageIndex\n  const newPageIndex = defaultState\n    ? defaultPageIndex\n    : (table.initialState.pagination?.pageIndex ?? defaultPageIndex)\n  if (newPageIndex === currentPageIndex) return\n  table_setPageIndex(table, newPageIndex)\n}\n\n/**\n * Resets only `pagination.pageSize`.\n *\n * With no argument, the reset uses `table.initialState.pagination?.pageSize`\n * or `10`. Passing `true` always resets the page size to `10`.\n *\n * @example\n * ```ts\n * table_resetPageSize(table)\n * table_resetPageSize(table, true)\n * ```\n */\nexport function table_resetPageSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  const currentPageSize =\n    table.atoms.pagination?.get()?.pageSize ?? defaultPageSize\n  const newPageSize = defaultState\n    ? defaultPageSize\n    : (table.initialState.pagination?.pageSize ?? defaultPageSize)\n  if (newPageSize === currentPageSize) return\n  table_setPageSize(table, newPageSize)\n}\n\n/**\n * Updates `pagination.pageSize` while preserving the current top row.\n *\n * The new size is clamped to at least `1`, and `pageIndex` is recalculated so\n * the row that was previously at the top of the page remains in view.\n *\n * @example\n * ```ts\n * table_setPageSize(table, (old) => old)\n * ```\n */\nexport function table_setPageSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: Updater<number>) {\n  table_setPagination(table, (old) => {\n    const pageSize = Math.max(1, functionalUpdate(updater, old.pageSize))\n    const topRowIndex = old.pageSize * old.pageIndex\n    const pageIndex = Math.floor(topRowIndex / pageSize)\n\n    return {\n      ...old,\n      pageIndex,\n      pageSize,\n    }\n  })\n}\n\n/**\n * Builds the zero-based page indexes available for the current page count.\n *\n * Unknown or empty page counts return an empty array; otherwise the result is\n * `[0, 1, ...pageCount - 1]`.\n *\n * @example\n * ```ts\n * const pageIndexes = table_getPageOptions(table)\n * ```\n */\nexport function table_getPageOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const pageCount = table_getPageCount(table)\n  let pageOptions: Array<number> = []\n  if (pageCount && pageCount > 0) {\n    pageOptions = [...new Array(pageCount)].fill(null).map((_, i) => i)\n  }\n  return pageOptions\n}\n\n/**\n * Checks whether the current page index can move backward.\n *\n * The first page is page index `0`, so only positive page indexes can navigate\n * to a previous page.\n *\n * @example\n * ```ts\n * const canGoBack = table_getCanPreviousPage(table)\n * ```\n */\nexport function table_getCanPreviousPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (table.atoms.pagination?.get()?.pageIndex ?? 0) > 0\n}\n\n/**\n * Checks whether the current page index can move forward.\n *\n * A `pageCount` of `-1` means the caller does not know the total page count, so\n * this returns `true`. A page count of `0` returns `false`.\n *\n * @example\n * ```ts\n * const canGoForward = table_getCanNextPage(table)\n * ```\n */\nexport function table_getCanNextPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const pageIndex = table.atoms.pagination?.get()?.pageIndex ?? defaultPageIndex\n\n  const pageCount = table_getPageCount(table)\n\n  if (pageCount === -1) {\n    return true\n  }\n\n  if (pageCount === 0) {\n    return false\n  }\n\n  return pageIndex < pageCount - 1\n}\n\n/**\n * Moves the table to the previous page.\n *\n * This delegates to `table_setPageIndex` so pagination state ownership and\n * updater semantics remain consistent.\n *\n * @example\n * ```ts\n * table_previousPage(table)\n * ```\n */\nexport function table_previousPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table_setPageIndex(table, (old) => old - 1)\n}\n\n/**\n * Moves the table to the next page.\n *\n * This delegates to `table_setPageIndex` so pagination state ownership and\n * updater semantics remain consistent.\n *\n * @example\n * ```ts\n * table_nextPage(table)\n * ```\n */\nexport function table_nextPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table_setPageIndex(table, (old) => {\n    return old + 1\n  })\n}\n\n/**\n * Moves the table to the first page.\n *\n * This is a convenience wrapper around `table_setPageIndex(table, 0)`.\n *\n * @example\n * ```ts\n * table_firstPage(table)\n * ```\n */\nexport function table_firstPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table_setPageIndex(table, 0)\n}\n\n/**\n * Moves the table to the last known page.\n *\n * The target page is derived from `table_getPageCount(table) - 1`.\n *\n * @example\n * ```ts\n * table_lastPage(table)\n * ```\n */\nexport function table_lastPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table_setPageIndex(table, table_getPageCount(table) - 1)\n}\n\n/**\n * Resolves the number of pages for the current pagination state.\n *\n * `options.pageCount` wins for manual pagination. Otherwise the value is\n * calculated from `table_getRowCount(table)` and the current `pageSize`.\n *\n * @example\n * ```ts\n * const pages = table_getPageCount(table)\n * ```\n */\nexport function table_getPageCount<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    table.options.pageCount ??\n    Math.ceil(\n      table_getRowCount(table) /\n        (table.atoms.pagination?.get()?.pageSize ?? defaultPageSize),\n    )\n  )\n}\n\n/**\n * Resolves the total row count used for pagination math.\n *\n * `options.rowCount` wins for manual pagination. Otherwise the count comes\n * from the pre-paginated row model so filtering, grouping, sorting, and\n * expansion are reflected before the page slice is applied.\n *\n * @example\n * ```ts\n * const rows = table_getRowCount(table)\n * ```\n */\nexport function table_getRowCount<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table.options.rowCount ?? table.getPrePaginatedRowModel().rows.length\n}\n"],"mappings":";;;AAMA,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;;;;;;;;;;;;AAaxB,SAAgB,4BAA6C;CAC3D,OAAO;EACL,WAAW;EACX,UAAU;CACZ;AACF;;;;;;;;;;;;;AAcA,SAAgB,yBAGd,OAAyC;CACzC,IACE,MAAM,QAAQ,gBACd,MAAM,QAAQ,sBACd,CAAC,MAAM,QAAQ,kBAEf,qBAAqB,KAAK;AAE9B;;;;;;;;;;;;;AAcA,SAAgB,oBAGd,OAAyC,SAAmC;;CAC5E,MAAM,eAAyC,QAAQ;EAGrD,OAFiBA,+BAAiB,SAAS,GAE7B;CAChB;CAEA,kDAAO,MAAM,SAAQ,uHAAqB,WAAW;AACvD;;;;;;;;;;;;;;AAeA,SAAgB,sBAGd,OAAyC,cAAwB;CACjE,oBACE,OACA,eACI,0BAA0B,IAC1BC,yBACE,MAAM,aAAa,cAAc,0BAA0B,CAC7D,CACN;AACF;;;;;;;;;;;;AAaA,SAAgB,mBAGd,OAAyC,SAA0B;CACnE,oBAAoB,QAAQ,QAAQ;EAClC,IAAI,YAAYD,+BAAiB,SAAS,IAAI,SAAS;EAEvD,MAAM,eACJ,OAAO,MAAM,QAAQ,cAAc,eACnC,MAAM,QAAQ,cAAc,KACxB,OAAO,mBACP,MAAM,QAAQ,YAAY;EAEhC,YAAY,KAAK,IAAI,GAAG,KAAK,IAAI,WAAW,YAAY,CAAC;EAEzD,OAAO;GACL,GAAG;GACH;EACF;CACF,CAAC;AACH;;;;;;;;;;;;;AAcA,SAAgB,qBAGd,OAAyC,cAAwB;;CACjE,MAAM,6CACJ,MAAM,MAAM,2GAAY,IAAI,iFAAG,cAAa;CAC9C,MAAM,eAAe,eACjB,6CACC,MAAM,aAAa,0FAAY,cAAa;CACjD,IAAI,iBAAiB,kBAAkB;CACvC,mBAAmB,OAAO,YAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,oBAGd,OAAyC,cAAwB;;CACjE,MAAM,6CACJ,MAAM,MAAM,8GAAY,IAAI,mFAAG,aAAY;CAC7C,MAAM,cAAc,eAChB,6CACC,MAAM,aAAa,4FAAY,aAAY;CAChD,IAAI,gBAAgB,iBAAiB;CACrC,kBAAkB,OAAO,WAAW;AACtC;;;;;;;;;;;;AAaA,SAAgB,kBAGd,OAAyC,SAA0B;CACnE,oBAAoB,QAAQ,QAAQ;EAClC,MAAM,WAAW,KAAK,IAAI,GAAGA,+BAAiB,SAAS,IAAI,QAAQ,CAAC;EACpE,MAAM,cAAc,IAAI,WAAW,IAAI;EACvC,MAAM,YAAY,KAAK,MAAM,cAAc,QAAQ;EAEnD,OAAO;GACL,GAAG;GACH;GACA;EACF;CACF,CAAC;AACH;;;;;;;;;;;;AAaA,SAAgB,qBAGd,OAAyC;CACzC,MAAM,YAAY,mBAAmB,KAAK;CAC1C,IAAI,cAA6B,CAAC;CAClC,IAAI,aAAa,YAAY,GAC3B,cAAc,CAAC,GAAG,IAAI,MAAM,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC;CAEpE,OAAO;AACT;;;;;;;;;;;;AAaA,SAAgB,yBAGd,OAAyC;;CACzC,mCAAQ,MAAM,MAAM,8GAAY,IAAI,mFAAG,cAAa,KAAK;AAC3D;;;;;;;;;;;;AAaA,SAAgB,qBAGd,OAAyC;;CACzC,MAAM,uCAAY,MAAM,MAAM,8GAAY,IAAI,mFAAG,cAAa;CAE9D,MAAM,YAAY,mBAAmB,KAAK;CAE1C,IAAI,cAAc,IAChB,OAAO;CAGT,IAAI,cAAc,GAChB,OAAO;CAGT,OAAO,YAAY,YAAY;AACjC;;;;;;;;;;;;AAaA,SAAgB,mBAGd,OAAyC;CACzC,OAAO,mBAAmB,QAAQ,QAAQ,MAAM,CAAC;AACnD;;;;;;;;;;;;AAaA,SAAgB,eAGd,OAAyC;CACzC,OAAO,mBAAmB,QAAQ,QAAQ;EACxC,OAAO,MAAM;CACf,CAAC;AACH;;;;;;;;;;;AAYA,SAAgB,gBAGd,OAAyC;CACzC,OAAO,mBAAmB,OAAO,CAAC;AACpC;;;;;;;;;;;AAYA,SAAgB,eAGd,OAAyC;CACzC,OAAO,mBAAmB,OAAO,mBAAmB,KAAK,IAAI,CAAC;AAChE;;;;;;;;;;;;AAaA,SAAgB,mBAGd,OAAyC;;CACzC,OACE,MAAM,QAAQ,aACd,KAAK,KACH,kBAAkB,KAAK,gCACpB,MAAM,MAAM,8GAAY,IAAI,mFAAG,aAAY,gBAChD;AAEJ;;;;;;;;;;;;;AAcA,SAAgB,kBAGd,OAAyC;CACzC,OAAO,MAAM,QAAQ,YAAY,MAAM,wBAAwB,CAAC,CAAC,KAAK;AACxE"}

package/dist/features/row-pagination/rowPaginationFeature.utils.d.cts

@@ -1,218 +0,0 @@
-import { RowData, Updater } from "../../types/type-utils.cjs";
-import { PaginationState } from "./rowPaginationFeature.types.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-import { Table_Internal } from "../../types/Table.cjs";
-
-//#region src/features/row-pagination/rowPaginationFeature.utils.d.ts
-/**
- * Creates the default pagination state used by the pagination feature.
- *
- * The feature default starts at the first page with a page size of 10. Reset
- * APIs use this value when `defaultState` is `true`.
- *
- * @example
- * ```ts
- * const pagination = getDefaultPaginationState()
- * ```
- */
-declare function getDefaultPaginationState(): PaginationState;
-/**
- * Resets the page index when a page-altering change should return to page 0.
- *
- * The reset runs when `autoResetAll`, `autoResetPageIndex`, or the default
- * client-side pagination behavior allows it. Manual pagination opts out unless
- * the reset options explicitly opt back in.
- *
- * @example
- * ```ts
- * table_autoResetPageIndex(table)
- * ```
- */
-declare function table_autoResetPageIndex<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
-/**
- * Routes a pagination updater through the table's pagination change handler.
- *
- * The updater may be a next state object or a function of the previous
- * `PaginationState`; controlled state and external atoms observe the same
- * updater path as the instance API.
- *
- * @example
- * ```ts
- * table_setPagination(table, (old) => old)
- * ```
- */
-declare function table_setPagination<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<PaginationState>): void | undefined;
-/**
- * Resets `pagination` to the configured initial state or feature default.
- *
- * With no argument, the reset clones `table.initialState.pagination` when it
- * exists. Passing `true` ignores initial state and resets to
- * `{ pageIndex: 0, pageSize: 10 }`.
- *
- * @example
- * ```ts
- * table_resetPagination(table)
- * table_resetPagination(table, true)
- * ```
- */
-declare function table_resetPagination<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
-/**
- * Updates `pagination.pageIndex` and clamps it to the known page range.
- *
- * Unknown page counts (`undefined` or `-1`) allow any non-negative page index.
- * Known page counts clamp the index between `0` and `pageCount - 1`.
- *
- * @example
- * ```ts
- * table_setPageIndex(table, (old) => old)
- * ```
- */
-declare function table_setPageIndex<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<number>): void;
-/**
- * Resets only `pagination.pageIndex`.
- *
- * With no argument, the reset uses `table.initialState.pagination?.pageIndex`
- * or `0`. Passing `true` always resets the page index to `0`.
- *
- * @example
- * ```ts
- * table_resetPageIndex(table)
- * table_resetPageIndex(table, true)
- * ```
- */
-declare function table_resetPageIndex<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
-/**
- * Resets only `pagination.pageSize`.
- *
- * With no argument, the reset uses `table.initialState.pagination?.pageSize`
- * or `10`. Passing `true` always resets the page size to `10`.
- *
- * @example
- * ```ts
- * table_resetPageSize(table)
- * table_resetPageSize(table, true)
- * ```
- */
-declare function table_resetPageSize<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
-/**
- * Updates `pagination.pageSize` while preserving the current top row.
- *
- * The new size is clamped to at least `1`, and `pageIndex` is recalculated so
- * the row that was previously at the top of the page remains in view.
- *
- * @example
- * ```ts
- * table_setPageSize(table, (old) => old)
- * ```
- */
-declare function table_setPageSize<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<number>): void;
-/**
- * Builds the zero-based page indexes available for the current page count.
- *
- * Unknown or empty page counts return an empty array; otherwise the result is
- * `[0, 1, ...pageCount - 1]`.
- *
- * @example
- * ```ts
- * const pageIndexes = table_getPageOptions(table)
- * ```
- */
-declare function table_getPageOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): number[];
-/**
- * Checks whether the current page index can move backward.
- *
- * The first page is page index `0`, so only positive page indexes can navigate
- * to a previous page.
- *
- * @example
- * ```ts
- * const canGoBack = table_getCanPreviousPage(table)
- * ```
- */
-declare function table_getCanPreviousPage<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
-/**
- * Checks whether the current page index can move forward.
- *
- * A `pageCount` of `-1` means the caller does not know the total page count, so
- * this returns `true`. A page count of `0` returns `false`.
- *
- * @example
- * ```ts
- * const canGoForward = table_getCanNextPage(table)
- * ```
- */
-declare function table_getCanNextPage<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
-/**
- * Moves the table to the previous page.
- *
- * This delegates to `table_setPageIndex` so pagination state ownership and
- * updater semantics remain consistent.
- *
- * @example
- * ```ts
- * table_previousPage(table)
- * ```
- */
-declare function table_previousPage<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
-/**
- * Moves the table to the next page.
- *
- * This delegates to `table_setPageIndex` so pagination state ownership and
- * updater semantics remain consistent.
- *
- * @example
- * ```ts
- * table_nextPage(table)
- * ```
- */
-declare function table_nextPage<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
-/**
- * Moves the table to the first page.
- *
- * This is a convenience wrapper around `table_setPageIndex(table, 0)`.
- *
- * @example
- * ```ts
- * table_firstPage(table)
- * ```
- */
-declare function table_firstPage<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
-/**
- * Moves the table to the last known page.
- *
- * The target page is derived from `table_getPageCount(table) - 1`.
- *
- * @example
- * ```ts
- * table_lastPage(table)
- * ```
- */
-declare function table_lastPage<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
-/**
- * Resolves the number of pages for the current pagination state.
- *
- * `options.pageCount` wins for manual pagination. Otherwise the value is
- * calculated from `table_getRowCount(table)` and the current `pageSize`.
- *
- * @example
- * ```ts
- * const pages = table_getPageCount(table)
- * ```
- */
-declare function table_getPageCount<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): number;
-/**
- * Resolves the total row count used for pagination math.
- *
- * `options.rowCount` wins for manual pagination. Otherwise the count comes
- * from the pre-paginated row model so filtering, grouping, sorting, and
- * expansion are reflected before the page slice is applied.
- *
- * @example
- * ```ts
- * const rows = table_getRowCount(table)
- * ```
- */
-declare function table_getRowCount<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): number;
-//#endregion
-export { getDefaultPaginationState, table_autoResetPageIndex, table_firstPage, table_getCanNextPage, table_getCanPreviousPage, table_getPageCount, table_getPageOptions, table_getRowCount, table_lastPage, table_nextPage, table_previousPage, table_resetPageIndex, table_resetPageSize, table_resetPagination, table_setPageIndex, table_setPageSize, table_setPagination };
-//# sourceMappingURL=rowPaginationFeature.utils.d.cts.map

package/dist/features/row-pagination/rowPaginationFeature.utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rowPaginationFeature.utils.js","names":[],"sources":["../../../src/features/row-pagination/rowPaginationFeature.utils.ts"],"sourcesContent":["import { cloneState, functionalUpdate } from '../../utils'\nimport type { RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { PaginationState } from './rowPaginationFeature.types'\n\nconst defaultPageIndex = 0\nconst defaultPageSize = 10\n\n/**\n * Creates the default pagination state used by the pagination feature.\n *\n * The feature default starts at the first page with a page size of 10. Reset\n * APIs use this value when `defaultState` is `true`.\n *\n * @example\n * ```ts\n * const pagination = getDefaultPaginationState()\n * ```\n */\nexport function getDefaultPaginationState(): PaginationState {\n  return {\n    pageIndex: defaultPageIndex,\n    pageSize: defaultPageSize,\n  }\n}\n\n/**\n * Resets the page index when a page-altering change should return to page 0.\n *\n * The reset runs when `autoResetAll`, `autoResetPageIndex`, or the default\n * client-side pagination behavior allows it. Manual pagination opts out unless\n * the reset options explicitly opt back in.\n *\n * @example\n * ```ts\n * table_autoResetPageIndex(table)\n * ```\n */\nexport function table_autoResetPageIndex<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  if (\n    table.options.autoResetAll ??\n    table.options.autoResetPageIndex ??\n    !table.options.manualPagination\n  ) {\n    table_resetPageIndex(table)\n  }\n}\n\n/**\n * Routes a pagination updater through the table's pagination change handler.\n *\n * The updater may be a next state object or a function of the previous\n * `PaginationState`; controlled state and external atoms observe the same\n * updater path as the instance API.\n *\n * @example\n * ```ts\n * table_setPagination(table, (old) => old)\n * ```\n */\nexport function table_setPagination<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: Updater<PaginationState>) {\n  const safeUpdater: Updater<PaginationState> = (old) => {\n    const newState = functionalUpdate(updater, old)\n\n    return newState\n  }\n\n  return table.options.onPaginationChange?.(safeUpdater)\n}\n\n/**\n * Resets `pagination` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.pagination` when it\n * exists. Passing `true` ignores initial state and resets to\n * `{ pageIndex: 0, pageSize: 10 }`.\n *\n * @example\n * ```ts\n * table_resetPagination(table)\n * table_resetPagination(table, true)\n * ```\n */\nexport function table_resetPagination<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setPagination(\n    table,\n    defaultState\n      ? getDefaultPaginationState()\n      : cloneState(\n          table.initialState.pagination ?? getDefaultPaginationState(),\n        ),\n  )\n}\n\n/**\n * Updates `pagination.pageIndex` and clamps it to the known page range.\n *\n * Unknown page counts (`undefined` or `-1`) allow any non-negative page index.\n * Known page counts clamp the index between `0` and `pageCount - 1`.\n *\n * @example\n * ```ts\n * table_setPageIndex(table, (old) => old)\n * ```\n */\nexport function table_setPageIndex<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: Updater<number>) {\n  table_setPagination(table, (old) => {\n    let pageIndex = functionalUpdate(updater, old.pageIndex)\n\n    const maxPageIndex =\n      typeof table.options.pageCount === 'undefined' ||\n      table.options.pageCount === -1\n        ? Number.MAX_SAFE_INTEGER\n        : table.options.pageCount - 1\n\n    pageIndex = Math.max(0, Math.min(pageIndex, maxPageIndex))\n\n    return {\n      ...old,\n      pageIndex,\n    }\n  })\n}\n\n/**\n * Resets only `pagination.pageIndex`.\n *\n * With no argument, the reset uses `table.initialState.pagination?.pageIndex`\n * or `0`. Passing `true` always resets the page index to `0`.\n *\n * @example\n * ```ts\n * table_resetPageIndex(table)\n * table_resetPageIndex(table, true)\n * ```\n */\nexport function table_resetPageIndex<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  const currentPageIndex =\n    table.atoms.pagination?.get()?.pageIndex ?? defaultPageIndex\n  const newPageIndex = defaultState\n    ? defaultPageIndex\n    : (table.initialState.pagination?.pageIndex ?? defaultPageIndex)\n  if (newPageIndex === currentPageIndex) return\n  table_setPageIndex(table, newPageIndex)\n}\n\n/**\n * Resets only `pagination.pageSize`.\n *\n * With no argument, the reset uses `table.initialState.pagination?.pageSize`\n * or `10`. Passing `true` always resets the page size to `10`.\n *\n * @example\n * ```ts\n * table_resetPageSize(table)\n * table_resetPageSize(table, true)\n * ```\n */\nexport function table_resetPageSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  const currentPageSize =\n    table.atoms.pagination?.get()?.pageSize ?? defaultPageSize\n  const newPageSize = defaultState\n    ? defaultPageSize\n    : (table.initialState.pagination?.pageSize ?? defaultPageSize)\n  if (newPageSize === currentPageSize) return\n  table_setPageSize(table, newPageSize)\n}\n\n/**\n * Updates `pagination.pageSize` while preserving the current top row.\n *\n * The new size is clamped to at least `1`, and `pageIndex` is recalculated so\n * the row that was previously at the top of the page remains in view.\n *\n * @example\n * ```ts\n * table_setPageSize(table, (old) => old)\n * ```\n */\nexport function table_setPageSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: Updater<number>) {\n  table_setPagination(table, (old) => {\n    const pageSize = Math.max(1, functionalUpdate(updater, old.pageSize))\n    const topRowIndex = old.pageSize * old.pageIndex\n    const pageIndex = Math.floor(topRowIndex / pageSize)\n\n    return {\n      ...old,\n      pageIndex,\n      pageSize,\n    }\n  })\n}\n\n/**\n * Builds the zero-based page indexes available for the current page count.\n *\n * Unknown or empty page counts return an empty array; otherwise the result is\n * `[0, 1, ...pageCount - 1]`.\n *\n * @example\n * ```ts\n * const pageIndexes = table_getPageOptions(table)\n * ```\n */\nexport function table_getPageOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const pageCount = table_getPageCount(table)\n  let pageOptions: Array<number> = []\n  if (pageCount && pageCount > 0) {\n    pageOptions = [...new Array(pageCount)].fill(null).map((_, i) => i)\n  }\n  return pageOptions\n}\n\n/**\n * Checks whether the current page index can move backward.\n *\n * The first page is page index `0`, so only positive page indexes can navigate\n * to a previous page.\n *\n * @example\n * ```ts\n * const canGoBack = table_getCanPreviousPage(table)\n * ```\n */\nexport function table_getCanPreviousPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (table.atoms.pagination?.get()?.pageIndex ?? 0) > 0\n}\n\n/**\n * Checks whether the current page index can move forward.\n *\n * A `pageCount` of `-1` means the caller does not know the total page count, so\n * this returns `true`. A page count of `0` returns `false`.\n *\n * @example\n * ```ts\n * const canGoForward = table_getCanNextPage(table)\n * ```\n */\nexport function table_getCanNextPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const pageIndex = table.atoms.pagination?.get()?.pageIndex ?? defaultPageIndex\n\n  const pageCount = table_getPageCount(table)\n\n  if (pageCount === -1) {\n    return true\n  }\n\n  if (pageCount === 0) {\n    return false\n  }\n\n  return pageIndex < pageCount - 1\n}\n\n/**\n * Moves the table to the previous page.\n *\n * This delegates to `table_setPageIndex` so pagination state ownership and\n * updater semantics remain consistent.\n *\n * @example\n * ```ts\n * table_previousPage(table)\n * ```\n */\nexport function table_previousPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table_setPageIndex(table, (old) => old - 1)\n}\n\n/**\n * Moves the table to the next page.\n *\n * This delegates to `table_setPageIndex` so pagination state ownership and\n * updater semantics remain consistent.\n *\n * @example\n * ```ts\n * table_nextPage(table)\n * ```\n */\nexport function table_nextPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table_setPageIndex(table, (old) => {\n    return old + 1\n  })\n}\n\n/**\n * Moves the table to the first page.\n *\n * This is a convenience wrapper around `table_setPageIndex(table, 0)`.\n *\n * @example\n * ```ts\n * table_firstPage(table)\n * ```\n */\nexport function table_firstPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table_setPageIndex(table, 0)\n}\n\n/**\n * Moves the table to the last known page.\n *\n * The target page is derived from `table_getPageCount(table) - 1`.\n *\n * @example\n * ```ts\n * table_lastPage(table)\n * ```\n */\nexport function table_lastPage<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table_setPageIndex(table, table_getPageCount(table) - 1)\n}\n\n/**\n * Resolves the number of pages for the current pagination state.\n *\n * `options.pageCount` wins for manual pagination. Otherwise the value is\n * calculated from `table_getRowCount(table)` and the current `pageSize`.\n *\n * @example\n * ```ts\n * const pages = table_getPageCount(table)\n * ```\n */\nexport function table_getPageCount<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    table.options.pageCount ??\n    Math.ceil(\n      table_getRowCount(table) /\n        (table.atoms.pagination?.get()?.pageSize ?? defaultPageSize),\n    )\n  )\n}\n\n/**\n * Resolves the total row count used for pagination math.\n *\n * `options.rowCount` wins for manual pagination. Otherwise the count comes\n * from the pre-paginated row model so filtering, grouping, sorting, and\n * expansion are reflected before the page slice is applied.\n *\n * @example\n * ```ts\n * const rows = table_getRowCount(table)\n * ```\n */\nexport function table_getRowCount<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table.options.rowCount ?? table.getPrePaginatedRowModel().rows.length\n}\n"],"mappings":"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"}

package/dist/features/row-pinning/rowPinningFeature.cjs

@@ -1,67 +0,0 @@
-const require_utils = require('../../utils.cjs');
-const require_rowPinningFeature_utils = require('./rowPinningFeature.utils.cjs');
-
-//#region src/features/row-pinning/rowPinningFeature.ts
-/**
-* Feature that adds row pinning state and APIs for top, center, and bottom rows.
-*/
-const rowPinningFeature = {
-	getInitialState: (initialState) => {
-		return {
-			...initialState,
-			rowPinning: {
-				...require_rowPinningFeature_utils.getDefaultRowPinningState(),
-				...initialState.rowPinning
-			}
-		};
-	},
-	getDefaultTableOptions: (table) => {
-		return { onRowPinningChange: require_utils.makeStateUpdater("rowPinning", table) };
-	},
-	assignRowPrototype: (prototype, table) => {
-		require_utils.assignPrototypeAPIs("rowPinningFeature", prototype, table, {
-			row_getCanPin: { fn: (row) => require_rowPinningFeature_utils.row_getCanPin(row) },
-			row_getIsPinned: { fn: (row) => require_rowPinningFeature_utils.row_getIsPinned(row) },
-			row_getPinnedIndex: {
-				fn: (row) => require_rowPinningFeature_utils.row_getPinnedIndex(row),
-				memoDeps: (row) => {
-					var _row$table$atoms$rowP;
-					return [row.table.getRowModel().rows, (_row$table$atoms$rowP = row.table.atoms.rowPinning) === null || _row$table$atoms$rowP === void 0 ? void 0 : _row$table$atoms$rowP.get()];
-				}
-			},
-			row_pin: { fn: (row, position, includeLeafRows, includeParentRows) => require_rowPinningFeature_utils.row_pin(row, position, includeLeafRows, includeParentRows) }
-		});
-	},
-	constructTableAPIs: (table) => {
-		require_utils.assignTableAPIs("rowPinningFeature", table, {
-			table_setRowPinning: { fn: (updater) => require_rowPinningFeature_utils.table_setRowPinning(table, updater) },
-			table_resetRowPinning: { fn: (defaultState) => require_rowPinningFeature_utils.table_resetRowPinning(table, defaultState) },
-			table_getIsSomeRowsPinned: { fn: (position) => require_rowPinningFeature_utils.table_getIsSomeRowsPinned(table, position) },
-			table_getTopRows: {
-				fn: () => require_rowPinningFeature_utils.table_getTopRows(table),
-				memoDeps: () => {
-					var _table$atoms$rowPinni;
-					return [table.getRowModel().rows, (_table$atoms$rowPinni = table.atoms.rowPinning) === null || _table$atoms$rowPinni === void 0 || (_table$atoms$rowPinni = _table$atoms$rowPinni.get()) === null || _table$atoms$rowPinni === void 0 ? void 0 : _table$atoms$rowPinni.top];
-				}
-			},
-			table_getBottomRows: {
-				fn: () => require_rowPinningFeature_utils.table_getBottomRows(table),
-				memoDeps: () => {
-					var _table$atoms$rowPinni2;
-					return [table.getRowModel().rows, (_table$atoms$rowPinni2 = table.atoms.rowPinning) === null || _table$atoms$rowPinni2 === void 0 || (_table$atoms$rowPinni2 = _table$atoms$rowPinni2.get()) === null || _table$atoms$rowPinni2 === void 0 ? void 0 : _table$atoms$rowPinni2.bottom];
-				}
-			},
-			table_getCenterRows: {
-				fn: () => require_rowPinningFeature_utils.table_getCenterRows(table),
-				memoDeps: () => {
-					var _table$atoms$rowPinni3;
-					return [table.getRowModel().rows, (_table$atoms$rowPinni3 = table.atoms.rowPinning) === null || _table$atoms$rowPinni3 === void 0 ? void 0 : _table$atoms$rowPinni3.get()];
-				}
-			}
-		});
-	}
-};
-
-//#endregion
-exports.rowPinningFeature = rowPinningFeature;
-//# sourceMappingURL=rowPinningFeature.cjs.map

package/dist/features/row-pinning/rowPinningFeature.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"rowPinningFeature.cjs","names":["getDefaultRowPinningState","makeStateUpdater","row_getCanPin","row_getIsPinned","row_getPinnedIndex","row_pin","table_setRowPinning","table_resetRowPinning","table_getIsSomeRowsPinned","table_getTopRows","table_getBottomRows","table_getCenterRows"],"sources":["../../../src/features/row-pinning/rowPinningFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  getDefaultRowPinningState,\n  row_getCanPin,\n  row_getIsPinned,\n  row_getPinnedIndex,\n  row_pin,\n  table_getBottomRows,\n  table_getCenterRows,\n  table_getIsSomeRowsPinned,\n  table_getTopRows,\n  table_resetRowPinning,\n  table_setRowPinning,\n} from './rowPinningFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Feature that adds row pinning state and APIs for top, center, and bottom rows.\n */\nexport const rowPinningFeature: TableFeature = {\n  getInitialState: (initialState) => {\n    return {\n      ...initialState,\n      rowPinning: {\n        ...getDefaultRowPinningState(),\n        ...initialState.rowPinning,\n      },\n    }\n  },\n\n  getDefaultTableOptions: (table) => {\n    return {\n      onRowPinningChange: makeStateUpdater('rowPinning', table),\n    }\n  },\n\n  assignRowPrototype: (prototype, table) => {\n    assignPrototypeAPIs('rowPinningFeature', prototype, table, {\n      row_getCanPin: {\n        fn: (row) => row_getCanPin(row),\n      },\n      row_getIsPinned: {\n        fn: (row) => row_getIsPinned(row),\n      },\n      row_getPinnedIndex: {\n        fn: (row) => row_getPinnedIndex(row),\n        memoDeps: (row) => [\n          row.table.getRowModel().rows,\n          row.table.atoms.rowPinning?.get(),\n        ],\n      },\n      row_pin: {\n        fn: (row, position, includeLeafRows, includeParentRows) =>\n          row_pin(row, position, includeLeafRows, includeParentRows),\n      },\n    })\n  },\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('rowPinningFeature', table, {\n      table_setRowPinning: {\n        fn: (updater) => table_setRowPinning(table, updater),\n      },\n      table_resetRowPinning: {\n        fn: (defaultState) => table_resetRowPinning(table, defaultState),\n      },\n      table_getIsSomeRowsPinned: {\n        fn: (position) => table_getIsSomeRowsPinned(table, position),\n      },\n      table_getTopRows: {\n        fn: () => table_getTopRows(table),\n        memoDeps: () => [\n          table.getRowModel().rows,\n          table.atoms.rowPinning?.get()?.top,\n        ],\n      },\n      table_getBottomRows: {\n        fn: () => table_getBottomRows(table),\n        memoDeps: () => [\n          table.getRowModel().rows,\n          table.atoms.rowPinning?.get()?.bottom,\n        ],\n      },\n      table_getCenterRows: {\n        fn: () => table_getCenterRows(table),\n        memoDeps: () => [\n          table.getRowModel().rows,\n          table.atoms.rowPinning?.get(),\n        ],\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AAuBA,MAAa,oBAAkC;CAC7C,kBAAkB,iBAAiB;EACjC,OAAO;GACL,GAAG;GACH,YAAY;IACV,GAAGA,0DAA0B;IAC7B,GAAG,aAAa;GAClB;EACF;CACF;CAEA,yBAAyB,UAAU;EACjC,OAAO,EACL,oBAAoBC,+BAAiB,cAAc,KAAK,EAC1D;CACF;CAEA,qBAAqB,WAAW,UAAU;EACxC,kCAAoB,qBAAqB,WAAW,OAAO;GACzD,eAAe,EACb,KAAK,QAAQC,8CAAc,GAAG,EAChC;GACA,iBAAiB,EACf,KAAK,QAAQC,gDAAgB,GAAG,EAClC;GACA,oBAAoB;IAClB,KAAK,QAAQC,mDAAmB,GAAG;IACnC,WAAW,QAAQ;;aACjB,IAAI,MAAM,YAAY,CAAC,CAAC,+BACxB,IAAI,MAAM,MAAM,0FAAY,IAAI,CAClC;;GACF;GACA,SAAS,EACP,KAAK,KAAK,UAAU,iBAAiB,sBACnCC,wCAAQ,KAAK,UAAU,iBAAiB,iBAAiB,EAC7D;EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,8BAAgB,qBAAqB,OAAO;GAC1C,qBAAqB,EACnB,KAAK,YAAYC,oDAAoB,OAAO,OAAO,EACrD;GACA,uBAAuB,EACrB,KAAK,iBAAiBC,sDAAsB,OAAO,YAAY,EACjE;GACA,2BAA2B,EACzB,KAAK,aAAaC,0DAA0B,OAAO,QAAQ,EAC7D;GACA,kBAAkB;IAChB,UAAUC,iDAAiB,KAAK;IAChC,gBAAgB;;aACd,MAAM,YAAY,CAAC,CAAC,+BACpB,MAAM,MAAM,2GAAY,IAAI,iFAAG,GACjC;;GACF;GACA,qBAAqB;IACnB,UAAUC,oDAAoB,KAAK;IACnC,gBAAgB;;aACd,MAAM,YAAY,CAAC,CAAC,gCACpB,MAAM,MAAM,8GAAY,IAAI,mFAAG,MACjC;;GACF;GACA,qBAAqB;IACnB,UAAUC,oDAAoB,KAAK;IACnC,gBAAgB;;aACd,MAAM,YAAY,CAAC,CAAC,gCACpB,MAAM,MAAM,4FAAY,IAAI,CAC9B;;GACF;EACF,CAAC;CACH;AACF"}