@tanstack/table-core 9.0.0-alpha.46 → 9.0.0-alpha.48

package/dist/features/column-sizing/columnSizingFeature.utils.cjs

@@ -4,26 +4,29 @@ const require_columnOrderingFeature_utils = require('../column-ordering/columnOr
 
 //#region src/features/column-sizing/columnSizingFeature.utils.ts
 /**
-* Returns the default column sizing state.
+* Creates the default committed column sizing state.
 *
-* Feature constructors use this value to initialize the table state or option defaults when no user value is provided.
+* The feature default is an empty map, so columns fall back to their column def
+* size or the built-in sizing defaults.
 *
 * @example
 * ```ts
-* const initialValue = getDefaultColumnSizingState()
+* const sizing = getDefaultColumnSizingState()
 * ```
 */
 function getDefaultColumnSizingState() {
 	return {};
 }
 /**
-* Returns the default column sizing column def.
+* Creates the built-in sizing defaults for column definitions.
 *
-* Feature constructors use this value to initialize the table state or option defaults when no user value is provided.
+* Columns default to `size: 150`, `minSize: 20`, and
+* `maxSize: Number.MAX_SAFE_INTEGER` unless overridden by column definitions or
+* table defaults.
 *
 * @example
 * ```ts
-* const initialValue = getDefaultColumnSizingColumnDef()
+* const defaults = getDefaultColumnSizingColumnDef()
 * ```
 */
 function getDefaultColumnSizingColumnDef() {
@@ -34,13 +37,14 @@ function getDefaultColumnSizingColumnDef() {
 	};
 }
 /**
-* Returns size for a column.
+* Resolves a column's current pixel size.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* Committed `state.columnSizing[column.id]` wins over `columnDef.size`, then the
+* built-in default size. The result is clamped between min and max size.
 *
 * @example
 * ```ts
-* const value = column_getSize(column)
+* const width = column_getSize(column)
 * ```
 */
 function column_getSize(column) {
@@ -50,13 +54,14 @@ function column_getSize(column) {
 	return Math.min(Math.max(column.columnDef.minSize ?? defaultSizes.minSize, columnSize ?? column.columnDef.size ?? defaultSizes.size), column.columnDef.maxSize ?? defaultSizes.maxSize);
 }
 /**
-* Returns start for a column.
+* Computes the offset from the start edge of a pinning region to this column.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* The value is the sum of all previous visible leaf column sizes in the
+* requested `'left'`, `'center'`, or `'right'` region.
 *
 * @example
 * ```ts
-* const value = column_getStart(column)
+* const leftOffset = column_getStart(column, 'left')
 * ```
 */
 function column_getStart(column, position) {
@@ -66,13 +71,14 @@ function column_getStart(column, position) {
 	return require_utils.callMemoOrStaticFn(prevColumn, "getStart", column_getStart, position) + require_utils.callMemoOrStaticFn(prevColumn, "getSize", column_getSize);
 }
 /**
-* Returns after for a column.
+* Computes the offset from the end edge of a pinning region after this column.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* The value is the sum of all following visible leaf column sizes in the
+* requested region.
 *
 * @example
 * ```ts
-* const value = column_getAfter(column)
+* const rightOffset = column_getAfter(column, 'right')
 * ```
 */
 function column_getAfter(column, position) {
@@ -83,13 +89,14 @@ function column_getAfter(column, position) {
 	return require_utils.callMemoOrStaticFn(nextColumn, "getSize", column_getSize) + require_utils.callMemoOrStaticFn(nextColumn, "getAfter", column_getAfter, position);
 }
 /**
-* Reset Size. for a column.
+* Removes this column's committed size override.
 *
-* This is the static implementation behind the matching column instance API.
+* After reset, the column resolves size from `columnDef.size` or built-in
+* defaults again.
 *
 * @example
 * ```ts
-* const value = column_resetSize(column)
+* column_resetSize(column)
 * ```
 */
 function column_resetSize(column) {
@@ -98,13 +105,14 @@ function column_resetSize(column) {
 	});
 }
 /**
-* Returns size for a header.
+* Computes a header's rendered size from its leaf headers.
 *
-* This is the static implementation behind the matching header instance API and can account for nested header groups.
+* Group headers sum the sizes of all descendant leaf columns. Leaf headers use
+* their column's current size.
 *
 * @example
 * ```ts
-* const value = header_getSize(header)
+* const width = header_getSize(header)
 * ```
 */
 function header_getSize(header) {
@@ -117,13 +125,14 @@ function header_getSize(header) {
 	return sum;
 }
 /**
-* Returns start for a header.
+* Computes a header's offset from the start of its header group.
 *
-* This is the static implementation behind the matching header instance API and can account for nested header groups.
+* The offset is the previous sibling header's start plus size, or `0` for the
+* first header in the group.
 *
 * @example
 * ```ts
-* const value = header_getStart(header)
+* const offset = header_getStart(header)
 * ```
 */
 function header_getStart(header) {
@@ -135,13 +144,14 @@ function header_getStart(header) {
 	return 0;
 }
 /**
-* Updates the table's column sizing state slice.
+* Routes a committed column sizing updater through the table's sizing handler.
 *
-* The updater follows TanStack Table updater semantics and is routed through the corresponding `on*Change` option or backing atom.
+* The updater may be a next size map or a function of the previous map,
+* matching the instance `table.setColumnSizing` behavior.
 *
 * @example
 * ```ts
-* table_setColumnSizing(table, (old) => old)
+* table_setColumnSizing(table, (old) => ({ ...old, age: 96 }))
 * ```
 */
 function table_setColumnSizing(table, updater) {
@@ -149,9 +159,10 @@ function table_setColumnSizing(table, updater) {
 	(_table$options$onColu = (_table$options = table.options).onColumnSizingChange) === null || _table$options$onColu === void 0 || _table$options$onColu.call(_table$options, updater);
 }
 /**
-* Resets the table's column sizing state slice.
+* Resets `columnSizing` to the configured initial state or feature default.
 *
-* By default the reset uses `table.initialState`; when supported, a blank/default reset bypasses the saved initial value.
+* With no argument, the reset clones `table.initialState.columnSizing` when it
+* exists. Passing `true` ignores initial state and resets to `{}`.
 *
 * @example
 * ```ts
@@ -163,13 +174,13 @@ function table_resetColumnSizing(table, defaultState) {
 	table_setColumnSizing(table, defaultState ? {} : require_utils.cloneState(table.initialState.columnSizing ?? {}));
 }
 /**
-* Returns total size for the table.
+* Sums the rendered size of the full table header row.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* This includes left, center, and right columns in the main header group.
 *
 * @example
 * ```ts
-* const value = table_getTotalSize(table)
+* const width = table_getTotalSize(table)
 * ```
 */
 function table_getTotalSize(table) {
@@ -179,13 +190,13 @@ function table_getTotalSize(table) {
 	}, 0)) ?? 0;
 }
 /**
-* Returns left total size for the table.
+* Sums the rendered size of the left pinned header region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* An empty left pinning region returns `0`.
 *
 * @example
 * ```ts
-* const value = table_getLeftTotalSize(table)
+* const width = table_getLeftTotalSize(table)
 * ```
 */
 function table_getLeftTotalSize(table) {
@@ -195,13 +206,13 @@ function table_getLeftTotalSize(table) {
 	}, 0)) ?? 0;
 }
 /**
-* Returns center total size for the table.
+* Sums the rendered size of the center, unpinned header region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* An empty center region returns `0`.
 *
 * @example
 * ```ts
-* const value = table_getCenterTotalSize(table)
+* const width = table_getCenterTotalSize(table)
 * ```
 */
 function table_getCenterTotalSize(table) {
@@ -211,13 +222,13 @@ function table_getCenterTotalSize(table) {
 	}, 0)) ?? 0;
 }
 /**
-* Returns right total size for the table.
+* Sums the rendered size of the right pinned header region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* An empty right pinning region returns `0`.
 *
 * @example
 * ```ts
-* const value = table_getRightTotalSize(table)
+* const width = table_getRightTotalSize(table)
 * ```
 */
 function table_getRightTotalSize(table) {

package/dist/features/column-sizing/columnSizingFeature.utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"columnSizingFeature.utils.cjs","names":["callMemoOrStaticFn","column_getIndex","table_getPinnedVisibleLeafColumns","cloneState","table_getLeftHeaderGroups","table_getCenterHeaderGroups","table_getRightHeaderGroups"],"sources":["../../../src/features/column-sizing/columnSizingFeature.utils.ts"],"sourcesContent":["import {\n  table_getCenterHeaderGroups,\n  table_getLeftHeaderGroups,\n  table_getPinnedVisibleLeafColumns,\n  table_getRightHeaderGroups,\n} from '../column-pinning/columnPinningFeature.utils'\nimport { column_getIndex } from '../column-ordering/columnOrderingFeature.utils'\nimport { callMemoOrStaticFn, cloneState } from '../../utils'\nimport type { ColumnPinningPosition } from '../column-pinning/columnPinningFeature.types'\nimport type { CellData, RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Header } from '../../types/Header'\nimport type { Column_Internal } from '../../types/Column'\nimport type { ColumnSizingState } from './columnSizingFeature.types'\n\n/**\n * Returns the default column sizing state.\n *\n * Feature constructors use this value to initialize the table state or option defaults when no user value is provided.\n *\n * @example\n * ```ts\n * const initialValue = getDefaultColumnSizingState()\n * ```\n */\nexport function getDefaultColumnSizingState(): ColumnSizingState {\n  return {}\n}\n\n/**\n * Returns the default column sizing column def.\n *\n * Feature constructors use this value to initialize the table state or option defaults when no user value is provided.\n *\n * @example\n * ```ts\n * const initialValue = getDefaultColumnSizingColumnDef()\n * ```\n */\nexport function getDefaultColumnSizingColumnDef() {\n  return {\n    size: 150,\n    minSize: 20,\n    maxSize: Number.MAX_SAFE_INTEGER,\n  }\n}\n\n/**\n * Returns size for a column.\n *\n * This derives the value from the column definition, table options, and the feature state atoms registered on the table.\n *\n * @example\n * ```ts\n * const value = column_getSize(column)\n * ```\n */\nexport function column_getSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): number {\n  const defaultSizes = getDefaultColumnSizingColumnDef()\n  const columnSize = column.table.atoms.columnSizing?.get()?.[column.id]\n\n  return Math.min(\n    Math.max(\n      column.columnDef.minSize ?? defaultSizes.minSize,\n      columnSize ?? column.columnDef.size ?? defaultSizes.size,\n    ),\n    column.columnDef.maxSize ?? defaultSizes.maxSize,\n  )\n}\n\n/**\n * Returns start for a column.\n *\n * This derives the value from the column definition, table options, and the feature state atoms registered on the table.\n *\n * @example\n * ```ts\n * const value = column_getStart(column)\n * ```\n */\nexport function column_getStart<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(\n  column: Column_Internal<TFeatures, TData, TValue>,\n  position: ColumnPinningPosition | 'center',\n): number {\n  const index = callMemoOrStaticFn(\n    column,\n    'getIndex',\n    column_getIndex,\n    position,\n  )\n  if (index <= 0) return 0\n\n  const visibleLeafColumns = callMemoOrStaticFn(\n    column.table,\n    'getPinnedVisibleLeafColumns',\n    table_getPinnedVisibleLeafColumns,\n    position,\n  )\n\n  const prevColumn = visibleLeafColumns[index - 1]!\n  return (\n    callMemoOrStaticFn(prevColumn, 'getStart', column_getStart, position) +\n    callMemoOrStaticFn(prevColumn, 'getSize', column_getSize)\n  )\n}\n\n/**\n * Returns after for a column.\n *\n * This derives the value from the column definition, table options, and the feature state atoms registered on the table.\n *\n * @example\n * ```ts\n * const value = column_getAfter(column)\n * ```\n */\nexport function column_getAfter<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(\n  column: Column_Internal<TFeatures, TData, TValue>,\n  position: ColumnPinningPosition | 'center',\n): number {\n  const visibleLeafColumns = callMemoOrStaticFn(\n    column.table,\n    'getPinnedVisibleLeafColumns',\n    table_getPinnedVisibleLeafColumns,\n    position,\n  )\n  const index = callMemoOrStaticFn(\n    column,\n    'getIndex',\n    column_getIndex,\n    position,\n  )\n  if (index < 0 || index >= visibleLeafColumns.length - 1) return 0\n\n  const nextColumn = visibleLeafColumns[index + 1]!\n  return (\n    callMemoOrStaticFn(nextColumn, 'getSize', column_getSize) +\n    callMemoOrStaticFn(nextColumn, 'getAfter', column_getAfter, position)\n  )\n}\n\n/**\n * Reset Size. for a column.\n *\n * This is the static implementation behind the matching column instance API.\n *\n * @example\n * ```ts\n * const value = column_resetSize(column)\n * ```\n */\nexport function column_resetSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  table_setColumnSizing(column.table, ({ [column.id]: _, ...rest }) => {\n    return rest\n  })\n}\n\n/**\n * Returns size for a header.\n *\n * This is the static implementation behind the matching header instance API and can account for nested header groups.\n *\n * @example\n * ```ts\n * const value = header_getSize(header)\n * ```\n */\nexport function header_getSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(header: Header<TFeatures, TData, TValue>) {\n  let sum = 0\n\n  const recurse = (h: Header<TFeatures, TData, TValue>) => {\n    if (h.subHeaders.length) {\n      h.subHeaders.forEach(recurse)\n    } else {\n      sum += column_getSize(h.column)\n    }\n  }\n\n  recurse(header)\n\n  return sum\n}\n\n/**\n * Returns start for a header.\n *\n * This is the static implementation behind the matching header instance API and can account for nested header groups.\n *\n * @example\n * ```ts\n * const value = header_getStart(header)\n * ```\n */\nexport function header_getStart<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(header: Header<TFeatures, TData, TValue>): number {\n  if (header.index > 0) {\n    const prevSiblingHeader = header.headerGroup?.headers[header.index - 1]\n    if (prevSiblingHeader) {\n      return (\n        callMemoOrStaticFn(prevSiblingHeader, 'getStart', header_getStart) +\n        callMemoOrStaticFn(prevSiblingHeader, 'getSize', header_getSize)\n      )\n    }\n  }\n\n  return 0\n}\n\n// Table APIs\n\n/**\n * Updates the table's column sizing state slice.\n *\n * The updater follows TanStack Table updater semantics and is routed through the corresponding `on*Change` option or backing atom.\n *\n * @example\n * ```ts\n * table_setColumnSizing(table, (old) => old)\n * ```\n */\nexport function table_setColumnSizing<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<ColumnSizingState>,\n) {\n  table.options.onColumnSizingChange?.(updater)\n}\n\n/**\n * Resets the table's column sizing state slice.\n *\n * By default the reset uses `table.initialState`; when supported, a blank/default reset bypasses the saved initial value.\n *\n * @example\n * ```ts\n * table_resetColumnSizing(table)\n * table_resetColumnSizing(table, true)\n * ```\n */\nexport function table_resetColumnSizing<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setColumnSizing(\n    table,\n    defaultState ? {} : cloneState(table.initialState.columnSizing ?? {}),\n  )\n}\n\n/**\n * Returns total size for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getTotalSize(table)\n * ```\n */\nexport function table_getTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    table.getHeaderGroups()[0]?.headers.reduce((sum, header) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n\n/**\n * Returns left total size for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getLeftTotalSize(table)\n * ```\n */\nexport function table_getLeftTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    callMemoOrStaticFn(\n      table,\n      'getLeftHeaderGroups',\n      table_getLeftHeaderGroups,\n    )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n\n/**\n * Returns center total size for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getCenterTotalSize(table)\n * ```\n */\nexport function table_getCenterTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    callMemoOrStaticFn(\n      table,\n      'getCenterHeaderGroups',\n      table_getCenterHeaderGroups,\n    )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n\n/**\n * Returns right total size for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getRightTotalSize(table)\n * ```\n */\nexport function table_getRightTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    callMemoOrStaticFn(\n      table,\n      'getRightHeaderGroups',\n      table_getRightHeaderGroups,\n    )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n"],"mappings":"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"}
+{"version":3,"file":"columnSizingFeature.utils.cjs","names":["callMemoOrStaticFn","column_getIndex","table_getPinnedVisibleLeafColumns","cloneState","table_getLeftHeaderGroups","table_getCenterHeaderGroups","table_getRightHeaderGroups"],"sources":["../../../src/features/column-sizing/columnSizingFeature.utils.ts"],"sourcesContent":["import {\n  table_getCenterHeaderGroups,\n  table_getLeftHeaderGroups,\n  table_getPinnedVisibleLeafColumns,\n  table_getRightHeaderGroups,\n} from '../column-pinning/columnPinningFeature.utils'\nimport { column_getIndex } from '../column-ordering/columnOrderingFeature.utils'\nimport { callMemoOrStaticFn, cloneState } from '../../utils'\nimport type { ColumnPinningPosition } from '../column-pinning/columnPinningFeature.types'\nimport type { CellData, RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Header } from '../../types/Header'\nimport type { Column_Internal } from '../../types/Column'\nimport type { ColumnSizingState } from './columnSizingFeature.types'\n\n/**\n * Creates the default committed column sizing state.\n *\n * The feature default is an empty map, so columns fall back to their column def\n * size or the built-in sizing defaults.\n *\n * @example\n * ```ts\n * const sizing = getDefaultColumnSizingState()\n * ```\n */\nexport function getDefaultColumnSizingState(): ColumnSizingState {\n  return {}\n}\n\n/**\n * Creates the built-in sizing defaults for column definitions.\n *\n * Columns default to `size: 150`, `minSize: 20`, and\n * `maxSize: Number.MAX_SAFE_INTEGER` unless overridden by column definitions or\n * table defaults.\n *\n * @example\n * ```ts\n * const defaults = getDefaultColumnSizingColumnDef()\n * ```\n */\nexport function getDefaultColumnSizingColumnDef() {\n  return {\n    size: 150,\n    minSize: 20,\n    maxSize: Number.MAX_SAFE_INTEGER,\n  }\n}\n\n/**\n * Resolves a column's current pixel size.\n *\n * Committed `state.columnSizing[column.id]` wins over `columnDef.size`, then the\n * built-in default size. The result is clamped between min and max size.\n *\n * @example\n * ```ts\n * const width = column_getSize(column)\n * ```\n */\nexport function column_getSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): number {\n  const defaultSizes = getDefaultColumnSizingColumnDef()\n  const columnSize = column.table.atoms.columnSizing?.get()?.[column.id]\n\n  return Math.min(\n    Math.max(\n      column.columnDef.minSize ?? defaultSizes.minSize,\n      columnSize ?? column.columnDef.size ?? defaultSizes.size,\n    ),\n    column.columnDef.maxSize ?? defaultSizes.maxSize,\n  )\n}\n\n/**\n * Computes the offset from the start edge of a pinning region to this column.\n *\n * The value is the sum of all previous visible leaf column sizes in the\n * requested `'left'`, `'center'`, or `'right'` region.\n *\n * @example\n * ```ts\n * const leftOffset = column_getStart(column, 'left')\n * ```\n */\nexport function column_getStart<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(\n  column: Column_Internal<TFeatures, TData, TValue>,\n  position: ColumnPinningPosition | 'center',\n): number {\n  const index = callMemoOrStaticFn(\n    column,\n    'getIndex',\n    column_getIndex,\n    position,\n  )\n  if (index <= 0) return 0\n\n  const visibleLeafColumns = callMemoOrStaticFn(\n    column.table,\n    'getPinnedVisibleLeafColumns',\n    table_getPinnedVisibleLeafColumns,\n    position,\n  )\n\n  const prevColumn = visibleLeafColumns[index - 1]!\n  return (\n    callMemoOrStaticFn(prevColumn, 'getStart', column_getStart, position) +\n    callMemoOrStaticFn(prevColumn, 'getSize', column_getSize)\n  )\n}\n\n/**\n * Computes the offset from the end edge of a pinning region after this column.\n *\n * The value is the sum of all following visible leaf column sizes in the\n * requested region.\n *\n * @example\n * ```ts\n * const rightOffset = column_getAfter(column, 'right')\n * ```\n */\nexport function column_getAfter<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(\n  column: Column_Internal<TFeatures, TData, TValue>,\n  position: ColumnPinningPosition | 'center',\n): number {\n  const visibleLeafColumns = callMemoOrStaticFn(\n    column.table,\n    'getPinnedVisibleLeafColumns',\n    table_getPinnedVisibleLeafColumns,\n    position,\n  )\n  const index = callMemoOrStaticFn(\n    column,\n    'getIndex',\n    column_getIndex,\n    position,\n  )\n  if (index < 0 || index >= visibleLeafColumns.length - 1) return 0\n\n  const nextColumn = visibleLeafColumns[index + 1]!\n  return (\n    callMemoOrStaticFn(nextColumn, 'getSize', column_getSize) +\n    callMemoOrStaticFn(nextColumn, 'getAfter', column_getAfter, position)\n  )\n}\n\n/**\n * Removes this column's committed size override.\n *\n * After reset, the column resolves size from `columnDef.size` or built-in\n * defaults again.\n *\n * @example\n * ```ts\n * column_resetSize(column)\n * ```\n */\nexport function column_resetSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  table_setColumnSizing(column.table, ({ [column.id]: _, ...rest }) => {\n    return rest\n  })\n}\n\n/**\n * Computes a header's rendered size from its leaf headers.\n *\n * Group headers sum the sizes of all descendant leaf columns. Leaf headers use\n * their column's current size.\n *\n * @example\n * ```ts\n * const width = header_getSize(header)\n * ```\n */\nexport function header_getSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(header: Header<TFeatures, TData, TValue>) {\n  let sum = 0\n\n  const recurse = (h: Header<TFeatures, TData, TValue>) => {\n    if (h.subHeaders.length) {\n      h.subHeaders.forEach(recurse)\n    } else {\n      sum += column_getSize(h.column)\n    }\n  }\n\n  recurse(header)\n\n  return sum\n}\n\n/**\n * Computes a header's offset from the start of its header group.\n *\n * The offset is the previous sibling header's start plus size, or `0` for the\n * first header in the group.\n *\n * @example\n * ```ts\n * const offset = header_getStart(header)\n * ```\n */\nexport function header_getStart<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(header: Header<TFeatures, TData, TValue>): number {\n  if (header.index > 0) {\n    const prevSiblingHeader = header.headerGroup?.headers[header.index - 1]\n    if (prevSiblingHeader) {\n      return (\n        callMemoOrStaticFn(prevSiblingHeader, 'getStart', header_getStart) +\n        callMemoOrStaticFn(prevSiblingHeader, 'getSize', header_getSize)\n      )\n    }\n  }\n\n  return 0\n}\n\n// Table APIs\n\n/**\n * Routes a committed column sizing updater through the table's sizing handler.\n *\n * The updater may be a next size map or a function of the previous map,\n * matching the instance `table.setColumnSizing` behavior.\n *\n * @example\n * ```ts\n * table_setColumnSizing(table, (old) => ({ ...old, age: 96 }))\n * ```\n */\nexport function table_setColumnSizing<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<ColumnSizingState>,\n) {\n  table.options.onColumnSizingChange?.(updater)\n}\n\n/**\n * Resets `columnSizing` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.columnSizing` when it\n * exists. Passing `true` ignores initial state and resets to `{}`.\n *\n * @example\n * ```ts\n * table_resetColumnSizing(table)\n * table_resetColumnSizing(table, true)\n * ```\n */\nexport function table_resetColumnSizing<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setColumnSizing(\n    table,\n    defaultState ? {} : cloneState(table.initialState.columnSizing ?? {}),\n  )\n}\n\n/**\n * Sums the rendered size of the full table header row.\n *\n * This includes left, center, and right columns in the main header group.\n *\n * @example\n * ```ts\n * const width = table_getTotalSize(table)\n * ```\n */\nexport function table_getTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    table.getHeaderGroups()[0]?.headers.reduce((sum, header) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n\n/**\n * Sums the rendered size of the left pinned header region.\n *\n * An empty left pinning region returns `0`.\n *\n * @example\n * ```ts\n * const width = table_getLeftTotalSize(table)\n * ```\n */\nexport function table_getLeftTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    callMemoOrStaticFn(\n      table,\n      'getLeftHeaderGroups',\n      table_getLeftHeaderGroups,\n    )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n\n/**\n * Sums the rendered size of the center, unpinned header region.\n *\n * An empty center region returns `0`.\n *\n * @example\n * ```ts\n * const width = table_getCenterTotalSize(table)\n * ```\n */\nexport function table_getCenterTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    callMemoOrStaticFn(\n      table,\n      'getCenterHeaderGroups',\n      table_getCenterHeaderGroups,\n    )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n\n/**\n * Sums the rendered size of the right pinned header region.\n *\n * An empty right pinning region returns `0`.\n *\n * @example\n * ```ts\n * const width = table_getRightTotalSize(table)\n * ```\n */\nexport function table_getRightTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    callMemoOrStaticFn(\n      table,\n      'getRightHeaderGroups',\n      table_getRightHeaderGroups,\n    )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n"],"mappings":"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"}

package/dist/features/column-sizing/columnSizingFeature.utils.d.cts

@@ -8,24 +8,27 @@ import { Table_Internal } from "../../types/Table.cjs";
 
 //#region src/features/column-sizing/columnSizingFeature.utils.d.ts
 /**
- * Returns the default column sizing state.
+ * Creates the default committed column sizing state.
  *
- * Feature constructors use this value to initialize the table state or option defaults when no user value is provided.
+ * The feature default is an empty map, so columns fall back to their column def
+ * size or the built-in sizing defaults.
  *
  * @example
  * ```ts
- * const initialValue = getDefaultColumnSizingState()
+ * const sizing = getDefaultColumnSizingState()
  * ```
  */
 declare function getDefaultColumnSizingState(): ColumnSizingState;
 /**
- * Returns the default column sizing column def.
+ * Creates the built-in sizing defaults for column definitions.
  *
- * Feature constructors use this value to initialize the table state or option defaults when no user value is provided.
+ * Columns default to `size: 150`, `minSize: 20`, and
+ * `maxSize: Number.MAX_SAFE_INTEGER` unless overridden by column definitions or
+ * table defaults.
  *
  * @example
  * ```ts
- * const initialValue = getDefaultColumnSizingColumnDef()
+ * const defaults = getDefaultColumnSizingColumnDef()
  * ```
  */
 declare function getDefaultColumnSizingColumnDef(): {
@@ -34,86 +37,94 @@ declare function getDefaultColumnSizingColumnDef(): {
   maxSize: number;
 };
 /**
- * Returns size for a column.
+ * Resolves a column's current pixel size.
  *
- * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ * Committed `state.columnSizing[column.id]` wins over `columnDef.size`, then the
+ * built-in default size. The result is clamped between min and max size.
  *
  * @example
  * ```ts
- * const value = column_getSize(column)
+ * const width = column_getSize(column)
  * ```
  */
 declare function column_getSize<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): number;
 /**
- * Returns start for a column.
+ * Computes the offset from the start edge of a pinning region to this column.
  *
- * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ * The value is the sum of all previous visible leaf column sizes in the
+ * requested `'left'`, `'center'`, or `'right'` region.
  *
  * @example
  * ```ts
- * const value = column_getStart(column)
+ * const leftOffset = column_getStart(column, 'left')
  * ```
  */
 declare function column_getStart<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>, position: ColumnPinningPosition | 'center'): number;
 /**
- * Returns after for a column.
+ * Computes the offset from the end edge of a pinning region after this column.
  *
- * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ * The value is the sum of all following visible leaf column sizes in the
+ * requested region.
  *
  * @example
  * ```ts
- * const value = column_getAfter(column)
+ * const rightOffset = column_getAfter(column, 'right')
  * ```
  */
 declare function column_getAfter<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>, position: ColumnPinningPosition | 'center'): number;
 /**
- * Reset Size. for a column.
+ * Removes this column's committed size override.
  *
- * This is the static implementation behind the matching column instance API.
+ * After reset, the column resolves size from `columnDef.size` or built-in
+ * defaults again.
  *
  * @example
  * ```ts
- * const value = column_resetSize(column)
+ * column_resetSize(column)
  * ```
  */
 declare function column_resetSize<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): void;
 /**
- * Returns size for a header.
+ * Computes a header's rendered size from its leaf headers.
  *
- * This is the static implementation behind the matching header instance API and can account for nested header groups.
+ * Group headers sum the sizes of all descendant leaf columns. Leaf headers use
+ * their column's current size.
  *
  * @example
  * ```ts
- * const value = header_getSize(header)
+ * const width = header_getSize(header)
  * ```
  */
 declare function header_getSize<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(header: Header<TFeatures, TData, TValue>): number;
 /**
- * Returns start for a header.
+ * Computes a header's offset from the start of its header group.
  *
- * This is the static implementation behind the matching header instance API and can account for nested header groups.
+ * The offset is the previous sibling header's start plus size, or `0` for the
+ * first header in the group.
  *
  * @example
  * ```ts
- * const value = header_getStart(header)
+ * const offset = header_getStart(header)
  * ```
  */
 declare function header_getStart<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(header: Header<TFeatures, TData, TValue>): number;
 /**
- * Updates the table's column sizing state slice.
+ * Routes a committed column sizing updater through the table's sizing handler.
  *
- * The updater follows TanStack Table updater semantics and is routed through the corresponding `on*Change` option or backing atom.
+ * The updater may be a next size map or a function of the previous map,
+ * matching the instance `table.setColumnSizing` behavior.
  *
  * @example
  * ```ts
- * table_setColumnSizing(table, (old) => old)
+ * table_setColumnSizing(table, (old) => ({ ...old, age: 96 }))
  * ```
  */
 declare function table_setColumnSizing<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<ColumnSizingState>): void;
 /**
- * Resets the table's column sizing state slice.
+ * Resets `columnSizing` to the configured initial state or feature default.
  *
- * By default the reset uses `table.initialState`; when supported, a blank/default reset bypasses the saved initial value.
+ * With no argument, the reset clones `table.initialState.columnSizing` when it
+ * exists. Passing `true` ignores initial state and resets to `{}`.
  *
  * @example
  * ```ts
@@ -123,46 +134,46 @@ declare function table_setColumnSizing<TFeatures extends TableFeatures, TData ex
  */
 declare function table_resetColumnSizing<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
 /**
- * Returns total size for the table.
+ * Sums the rendered size of the full table header row.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * This includes left, center, and right columns in the main header group.
  *
  * @example
  * ```ts
- * const value = table_getTotalSize(table)
+ * const width = table_getTotalSize(table)
  * ```
  */
 declare function table_getTotalSize<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): number;
 /**
- * Returns left total size for the table.
+ * Sums the rendered size of the left pinned header region.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * An empty left pinning region returns `0`.
  *
  * @example
  * ```ts
- * const value = table_getLeftTotalSize(table)
+ * const width = table_getLeftTotalSize(table)
  * ```
  */
 declare function table_getLeftTotalSize<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any;
 /**
- * Returns center total size for the table.
+ * Sums the rendered size of the center, unpinned header region.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * An empty center region returns `0`.
  *
  * @example
  * ```ts
- * const value = table_getCenterTotalSize(table)
+ * const width = table_getCenterTotalSize(table)
  * ```
  */
 declare function table_getCenterTotalSize<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any;
 /**
- * Returns right total size for the table.
+ * Sums the rendered size of the right pinned header region.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * An empty right pinning region returns `0`.
  *
  * @example
  * ```ts
- * const value = table_getRightTotalSize(table)
+ * const width = table_getRightTotalSize(table)
  * ```
  */
 declare function table_getRightTotalSize<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any;