npm - @tanstack/table-core - Versions diffs - 9.0.0-beta.52 → 9.0.0-beta.53 - Mend

@tanstack/table-core 9.0.0-beta.52 → 9.0.0-beta.53

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (680) hide show

package/dist/features/column-sizing/columnSizingFeature.types.d.cts DELETED Viewed

@@ -1,139 +0,0 @@
-import { OnChangeFn, Updater } from "../../types/type-utils.cjs";
-import { ColumnPinningPosition } from "../column-pinning/columnPinningFeature.types.cjs";
-//#region src/features/column-sizing/columnSizingFeature.types.d.ts
-interface TableState_ColumnSizing {
-  columnSizing: ColumnSizingState;
-}
-type ColumnSizingState = Record<string, number>;
-interface ColumnOffsets {
-  /**
-   * Offset from the start edge of the region to each column's start edge,
-   * keyed by column id.
-   */
-  starts: Record<string, number>;
-  /**
-   * Offset from the end edge of the region to each column's end edge, keyed by
-   * column id.
-   */
-  afters: Record<string, number>;
-}
-interface ColumnOffsetsByPosition {
-  /**
-   * Offsets across all visible leaf columns, ignoring pinning regions.
-   */
-  all: ColumnOffsets;
-  /**
-   * Offsets within the center (unpinned) region.
-   */
-  center: ColumnOffsets;
-  /**
-   * Offsets within the logical start pinned region.
-   *
-   * In LTR languages/layouts, start usually corresponds to left. In RTL
-   * languages/layouts, start usually corresponds to right.
-   */
-  start: ColumnOffsets;
-  /**
-   * Offsets within the logical end pinned region.
-   *
-   * In LTR languages/layouts, end usually corresponds to right. In RTL
-   * languages/layouts, end usually corresponds to left.
-   */
-  end: ColumnOffsets;
-}
-interface TableOptions_ColumnSizing {
-  /**
-   * Called with an updater when committed column sizing state changes. Pair
-   * this with `state.columnSizing` when using external state; external atoms
-   * can own the slice without this callback.
-   */
-  onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
-}
-type ColumnSizingDefaultOptions = Pick<TableOptions_ColumnSizing, 'onColumnSizingChange'>;
-interface Table_ColumnSizing {
-  /**
-   * Sums the current sizes of visible center-region leaf columns.
-   */
-  getCenterTotalSize: () => number;
-  /**
-   * Returns memoized column offset maps (start and after offsets keyed by
-   * column id) for each pinning region plus the full visible leaf column list.
-   *
-   * Backs `column.getStart()` and `column.getAfter()` with O(1) lookups.
-   */
-  getColumnOffsets: () => ColumnOffsetsByPosition;
-  /**
-   * Sums the current sizes of visible logical start-pinned leaf columns.
-   */
-  getStartTotalSize: () => number;
-  /**
-   * Sums the current sizes of visible logical end-pinned leaf columns.
-   */
-  getEndTotalSize: () => number;
-  /**
-   * Sums the current sizes of all visible leaf columns.
-   */
-  getTotalSize: () => number;
-  /**
-   * Resets column sizing to `initialState.columnSizing`. Pass `true` to reset
-   * to the feature default of `{}`.
-   */
-  resetColumnSizing: (defaultState?: boolean) => void;
-  /**
-   * Updates committed column sizing state with a next map or updater function.
-   */
-  setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
-}
-interface ColumnDef_ColumnSizing {
-  /**
-   * Upper bound used when resolving this column's size.
-   */
-  maxSize?: number;
-  /**
-   * Lower bound used when resolving this column's size.
-   */
-  minSize?: number;
-  /**
-   * Initial size used before column sizing state overrides it.
-   */
-  size?: number;
-}
-interface Column_ColumnSizing {
-  /**
-   * Measures the offset from this column's end edge to the end of its region.
-   *
-   * Pass a pinned region to measure within that logical region. The value is
-   * the sum of visible leaf column sizes after this column.
-   */
-  getAfter: (position?: ColumnPinningPosition | 'center') => number;
-  /**
-   * Resolves the column's current size after state and min/max constraints.
-   */
-  getSize: () => number;
-  /**
-   * Measures the offset from the start of this column's region to its start
-   * edge.
-   *
-   * Pass a pinned region to measure within that logical region. The value is
-   * the sum of visible leaf column sizes before this column.
-   */
-  getStart: (position?: ColumnPinningPosition | 'center') => number;
-  /**
-   * Resets the column to its initial size.
-   */
-  resetSize: () => void;
-}
-interface Header_ColumnSizing {
-  /**
-   * Computes this header's rendered size from its leaf columns.
-   */
-  getSize: () => number;
-  /**
-   * Returns the offset measurement along the row-axis (usually the x-axis for standard tables) for the header. This is effectively a sum of the offset measurements of all preceding headers.
-   */
-  getStart: (position?: ColumnPinningPosition) => number;
-}
-//#endregion
-export { ColumnDef_ColumnSizing, ColumnOffsets, ColumnOffsetsByPosition, ColumnSizingDefaultOptions, ColumnSizingState, Column_ColumnSizing, Header_ColumnSizing, TableOptions_ColumnSizing, TableState_ColumnSizing, Table_ColumnSizing };
-//# sourceMappingURL=columnSizingFeature.types.d.cts.map

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

@@ -1,299 +0,0 @@
-const require_utils = require('../../utils.cjs');
-const require_columnPinningFeature_utils = require('../column-pinning/columnPinningFeature.utils.cjs');
-//#region src/features/column-sizing/columnSizingFeature.utils.ts
-/**
-* Creates the default committed column sizing state.
-*
-* 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 sizing = getDefaultColumnSizingState()
-* ```
-*/
-function getDefaultColumnSizingState() {
-	return require_utils.makeObjectMap();
-}
-/**
-* Creates the built-in sizing defaults for column definitions.
-*
-* Columns default to `size: 150`, `minSize: 20`, and
-* `maxSize: Number.MAX_SAFE_INTEGER` unless overridden by column definitions or
-* table defaults.
-*
-* @example
-* ```ts
-* const defaults = getDefaultColumnSizingColumnDef()
-* ```
-*/
-function getDefaultColumnSizingColumnDef() {
-	return {
-		size: 150,
-		minSize: 20,
-		maxSize: Number.MAX_SAFE_INTEGER
-	};
-}
-/**
-* Resolves a column's current pixel size.
-*
-* 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 width = column_getSize(column)
-* ```
-*/
-function column_getSize(column) {
-	const defaultSizes = getDefaultColumnSizingColumnDef();
-	const columnSizing = column.table.atoms.columnSizing?.get();
-	const columnSize = columnSizing && require_utils.hasOwn(columnSizing, column.id) ? columnSizing[column.id] : void 0;
-	return Math.min(Math.max(column.columnDef.minSize ?? defaultSizes.minSize, columnSize ?? column.columnDef.size ?? defaultSizes.size), column.columnDef.maxSize ?? defaultSizes.maxSize);
-}
-function buildColumnOffsets(columns) {
-	const starts = require_utils.makeObjectMap();
-	const afters = require_utils.makeObjectMap();
-	const sizes = new Array(columns.length);
-	let start = 0;
-	for (let i = 0; i < columns.length; i++) {
-		const column = columns[i];
-		const size = require_utils.callMemoOrStaticFn(column, "getSize", column_getSize);
-		sizes[i] = size;
-		starts[column.id] = start;
-		start += size;
-	}
-	let after = 0;
-	for (let i = columns.length - 1; i >= 0; i--) {
-		afters[columns[i].id] = after;
-		after += sizes[i];
-	}
-	return {
-		starts,
-		afters
-	};
-}
-/**
-* Builds start and after offset maps for every visible leaf column, computed
-* once per pinning region plus the full visible list.
-*
-* A single table-level memo of this result backs all `column.getStart()` and
-* `column.getAfter()` calls with O(1) lookups.
-*
-* @example
-* ```ts
-* const offsets = table_getColumnOffsets(table)
-* const startOffset = offsets.start.starts[column.id]
-* ```
-*/
-function table_getColumnOffsets(table) {
-	return {
-		all: buildColumnOffsets(require_columnPinningFeature_utils.table_getPinnedVisibleLeafColumns(table)),
-		center: buildColumnOffsets(require_columnPinningFeature_utils.table_getPinnedVisibleLeafColumns(table, "center")),
-		start: buildColumnOffsets(require_columnPinningFeature_utils.table_getPinnedVisibleLeafColumns(table, "start")),
-		end: buildColumnOffsets(require_columnPinningFeature_utils.table_getPinnedVisibleLeafColumns(table, "end"))
-	};
-}
-function toOffsetsKey(position) {
-	return position === "start" ? "start" : position === "end" ? "end" : position === "center" ? "center" : "all";
-}
-/**
-* Computes the offset from the start edge of a pinning region to this column.
-*
-* The value is the sum of all previous visible leaf column sizes in the
-* requested `'start'`, `'center'`, or `'end'` region.
-*
-* `start` and `end` are logical positions. In LTR languages/layouts, `start`
-* usually corresponds to left and `end` to right. In RTL languages/layouts,
-* `start` usually corresponds to right and `end` to left.
-*
-* @example
-* ```ts
-* const startOffset = column_getStart(column, 'start')
-* ```
-*/
-function column_getStart(column, position) {
-	return require_utils.callMemoOrStaticFn(column.table, "getColumnOffsets", table_getColumnOffsets)[toOffsetsKey(position)].starts[column.id] ?? 0;
-}
-/**
-* Computes the offset from the end edge of a pinning region after this column.
-*
-* The value is the sum of all following visible leaf column sizes in the
-* requested region.
-*
-* @example
-* ```ts
-* const endOffset = column_getAfter(column, 'end')
-* ```
-*/
-function column_getAfter(column, position) {
-	return require_utils.callMemoOrStaticFn(column.table, "getColumnOffsets", table_getColumnOffsets)[toOffsetsKey(position)].afters[column.id] ?? 0;
-}
-/**
-* Removes this column's committed size override.
-*
-* After reset, the column resolves size from `columnDef.size` or built-in
-* defaults again.
-*
-* @example
-* ```ts
-* column_resetSize(column)
-* ```
-*/
-function column_resetSize(column) {
-	table_setColumnSizing(column.table, (old) => {
-		const rest = require_utils.makeObjectMap();
-		const columnIds = Object.keys(old);
-		for (let i = 0; i < columnIds.length; i++) {
-			const columnId = columnIds[i];
-			if (columnId !== column.id) rest[columnId] = old[columnId];
-		}
-		return rest;
-	});
-}
-/**
-* Computes a header's rendered size from its leaf headers.
-*
-* Group headers sum the sizes of all descendant leaf columns. Leaf headers use
-* their column's current size.
-*
-* @example
-* ```ts
-* const width = header_getSize(header)
-* ```
-*/
-function header_getSize(header) {
-	let sum = 0;
-	const recurse = (h) => {
-		if (h.subHeaders.length) h.subHeaders.forEach(recurse);
-		else sum += column_getSize(h.column);
-	};
-	recurse(header);
-	return sum;
-}
-/**
-* Computes a header's offset from the start of its header group.
-*
-* The offset is the previous sibling header's start plus size, or `0` for the
-* first header in the group.
-*
-* @example
-* ```ts
-* const offset = header_getStart(header)
-* ```
-*/
-function header_getStart(header) {
-	if (header.index > 0) {
-		const prevSiblingHeader = header.headerGroup?.headers[header.index - 1];
-		if (prevSiblingHeader) return require_utils.callMemoOrStaticFn(prevSiblingHeader, "getStart", header_getStart) + require_utils.callMemoOrStaticFn(prevSiblingHeader, "getSize", header_getSize);
-	}
-	return 0;
-}
-/**
-* Routes a committed column sizing updater through the table's sizing handler.
-*
-* 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, age: 96 }))
-* ```
-*/
-function table_setColumnSizing(table, updater) {
-	table.options.onColumnSizingChange?.(updater);
-}
-/**
-* Resets `columnSizing` to the configured initial state or feature default.
-*
-* With no argument, the reset clones `table.initialState.columnSizing` when it
-* exists. Passing `true` ignores initial state and resets to `{}`.
-*
-* @example
-* ```ts
-* table_resetColumnSizing(table)
-* table_resetColumnSizing(table, true)
-* ```
-*/
-function table_resetColumnSizing(table, defaultState) {
-	table_setColumnSizing(table, defaultState ? require_utils.makeObjectMap() : Object.assign(require_utils.makeObjectMap(), require_utils.cloneState(table.initialState.columnSizing ?? {})));
-}
-/**
-* Sums the rendered size of the full table header row.
-*
-* This includes start, center, and end columns in the main header group.
-*
-* @example
-* ```ts
-* const width = table_getTotalSize(table)
-* ```
-*/
-function table_getTotalSize(table) {
-	return table.getHeaderGroups()[0]?.headers.reduce((sum, header) => {
-		return sum + header_getSize(header);
-	}, 0) ?? 0;
-}
-/**
-* Sums the rendered size of the logical start pinned header region.
-*
-* An empty start pinning region returns `0`.
-*
-* @example
-* ```ts
-* const width = table_getStartTotalSize(table)
-* ```
-*/
-function table_getStartTotalSize(table) {
-	return require_utils.callMemoOrStaticFn(table, "getStartHeaderGroups", require_columnPinningFeature_utils.table_getStartHeaderGroups)[0]?.headers.reduce((sum, header) => {
-		return sum + header_getSize(header);
-	}, 0) ?? 0;
-}
-/**
-* Sums the rendered size of the center, unpinned header region.
-*
-* An empty center region returns `0`.
-*
-* @example
-* ```ts
-* const width = table_getCenterTotalSize(table)
-* ```
-*/
-function table_getCenterTotalSize(table) {
-	return require_utils.callMemoOrStaticFn(table, "getCenterHeaderGroups", require_columnPinningFeature_utils.table_getCenterHeaderGroups)[0]?.headers.reduce((sum, header) => {
-		return sum + header_getSize(header);
-	}, 0) ?? 0;
-}
-/**
-* Sums the rendered size of the logical end pinned header region.
-*
-* An empty end pinning region returns `0`.
-*
-* @example
-* ```ts
-* const width = table_getEndTotalSize(table)
-* ```
-*/
-function table_getEndTotalSize(table) {
-	return require_utils.callMemoOrStaticFn(table, "getEndHeaderGroups", require_columnPinningFeature_utils.table_getEndHeaderGroups)[0]?.headers.reduce((sum, header) => {
-		return sum + header_getSize(header);
-	}, 0) ?? 0;
-}
-//#endregion
-exports.column_getAfter = column_getAfter;
-exports.column_getSize = column_getSize;
-exports.column_getStart = column_getStart;
-exports.column_resetSize = column_resetSize;
-exports.getDefaultColumnSizingColumnDef = getDefaultColumnSizingColumnDef;
-exports.getDefaultColumnSizingState = getDefaultColumnSizingState;
-exports.header_getSize = header_getSize;
-exports.header_getStart = header_getStart;
-exports.table_getCenterTotalSize = table_getCenterTotalSize;
-exports.table_getColumnOffsets = table_getColumnOffsets;
-exports.table_getEndTotalSize = table_getEndTotalSize;
-exports.table_getStartTotalSize = table_getStartTotalSize;
-exports.table_getTotalSize = table_getTotalSize;
-exports.table_resetColumnSizing = table_resetColumnSizing;
-exports.table_setColumnSizing = table_setColumnSizing;
-//# sourceMappingURL=columnSizingFeature.utils.cjs.map

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

@@ -1 +0,0 @@

- {"version":3,"file":"columnSizingFeature.utils.cjs","names":["makeObjectMap","hasOwn","callMemoOrStaticFn","table_getPinnedVisibleLeafColumns","cloneState","table_getStartHeaderGroups","table_getCenterHeaderGroups","table_getEndHeaderGroups"],"sources":["../../../src/features/column-sizing/columnSizingFeature.utils.ts"],"sourcesContent":["import {\n table_getCenterHeaderGroups,\n table_getEndHeaderGroups,\n table_getPinnedVisibleLeafColumns,\n table_getStartHeaderGroups,\n} from '../column-pinning/columnPinningFeature.utils'\nimport {\n callMemoOrStaticFn,\n cloneState,\n hasOwn,\n makeObjectMap,\n} 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 {\n ColumnOffsets,\n ColumnOffsetsByPosition,\n ColumnSizingState,\n} 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 makeObjectMap()\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 columnSizing = column.table.atoms.columnSizing?.get()\n const columnSize =\n columnSizing && hasOwn(columnSizing, column.id)\n ? columnSizing[column.id]\n : undefined\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\nfunction buildColumnOffsets<\n TFeatures extends TableFeatures,\n TData extends RowData,\n>(columns: Array<Column_Internal<TFeatures, TData, unknown>>): ColumnOffsets {\n const starts = makeObjectMap<number>()\n const afters = makeObjectMap<number>()\n const sizes = new Array<number>(columns.length)\n\n let start = 0\n for (let i = 0; i < columns.length; i++) {\n const column = columns[i]!\n const size = callMemoOrStaticFn(column, 'getSize', column_getSize)\n sizes[i] = size\n starts[column.id] = start\n start += size\n }\n\n let after = 0\n for (let i = columns.length - 1; i >= 0; i--) {\n afters[columns[i]!.id] = after\n after += sizes[i]!\n }\n\n return { starts, afters }\n}\n\n/**\n * Builds start and after offset maps for every visible leaf column, computed\n * once per pinning region plus the full visible list.\n *\n * A single table-level memo of this result backs all `column.getStart()` and\n * `column.getAfter()` calls with O(1) lookups.\n *\n * @example\n * ```ts\n * const offsets = table_getColumnOffsets(table)\n * const startOffset = offsets.start.starts[column.id]\n * ```\n */\nexport function table_getColumnOffsets<\n TFeatures extends TableFeatures,\n TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): ColumnOffsetsByPosition {\n return {\n all: buildColumnOffsets(\n table_getPinnedVisibleLeafColumns(table) as Array<\n Column_Internal<TFeatures, TData, unknown>\n >,\n ),\n center: buildColumnOffsets(\n table_getPinnedVisibleLeafColumns(table, 'center') as Array<\n Column_Internal<TFeatures, TData, unknown>\n >,\n ),\n start: buildColumnOffsets(\n table_getPinnedVisibleLeafColumns(table, 'start') as Array<\n Column_Internal<TFeatures, TData, unknown>\n >,\n ),\n end: buildColumnOffsets(\n table_getPinnedVisibleLeafColumns(table, 'end') as Array<\n Column_Internal<TFeatures, TData, unknown>\n >,\n ),\n }\n}\n\nfunction toOffsetsKey(\n position: ColumnPinningPosition | 'center' | undefined,\n): keyof ColumnOffsetsByPosition {\n return position === 'start'\n ? 'start'\n : position === 'end'\n ? 'end'\n : position === 'center'\n ? 'center'\n : 'all' // undefined | false use the full visible list\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 `'start'`, `'center'`, or `'end'` region.\n *\n * `start` and `end` are logical positions. In LTR languages/layouts, `start`\n * usually corresponds to left and `end` to right. In RTL languages/layouts,\n * `start` usually corresponds to right and `end` to left.\n *\n * @example\n * ```ts\n * const startOffset = column_getStart(column, 'start')\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 offsets = callMemoOrStaticFn(\n column.table,\n 'getColumnOffsets',\n table_getColumnOffsets,\n )\n return offsets[toOffsetsKey(position)].starts[column.id] ?? 0\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 endOffset = column_getAfter(column, 'end')\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 offsets = callMemoOrStaticFn(\n column.table,\n 'getColumnOffsets',\n table_getColumnOffsets,\n )\n return offsets[toOffsetsKey(position)].afters[column.id] ?? 0\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, (old) => {\n const rest = makeObjectMap<number>()\n const columnIds = Object.keys(old)\n for (let i = 0; i < columnIds.length; i++) {\n const columnId = columnIds[i]!\n if (columnId !== column.id) {\n rest[columnId] = old[columnId]!\n }\n }\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\n ? makeObjectMap()\n : Object.assign(\n makeObjectMap<number>(),\n cloneState(table.initialState.columnSizing ?? {}),\n ),\n )\n}\n\n/**\n * Sums the rendered size of the full table header row.\n *\n * This includes start, center, and end 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 logical start pinned header region.\n *\n * An empty start pinning region returns `0`.\n *\n * @example\n * ```ts\n * const width = table_getStartTotalSize(table)\n * ```\n */\nexport function table_getStartTotalSize<\n TFeatures extends TableFeatures,\n TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n return (\n callMemoOrStaticFn(\n table,\n 'getStartHeaderGroups',\n table_getStartHeaderGroups,\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 logical end pinned header region.\n *\n * An empty end pinning region returns `0`.\n *\n * @example\n * ```ts\n * const width = table_getEndTotalSize(table)\n * ```\n */\nexport function table_getEndTotalSize<\n TFeatures extends TableFeatures,\n TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n return (\n callMemoOrStaticFn(\n table,\n 'getEndHeaderGroups',\n table_getEndHeaderGroups,\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 DELETED Viewed

@@ -1,200 +0,0 @@
-import { CellData, RowData, Updater } from "../../types/type-utils.cjs";
-import { ColumnPinningPosition } from "../column-pinning/columnPinningFeature.types.cjs";
-import { ColumnOffsetsByPosition, ColumnSizingState } from "./columnSizingFeature.types.cjs";
-import { Header } from "../../types/Header.cjs";
-import { Table } from "../../types/Table.cjs";
-import { Column } from "../../types/Column.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-//#region src/features/column-sizing/columnSizingFeature.utils.d.ts
-/**
- * Creates the default committed column sizing state.
- *
- * 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 sizing = getDefaultColumnSizingState()
- * ```
- */
-declare function getDefaultColumnSizingState(): ColumnSizingState;
-/**
- * Creates the built-in sizing defaults for column definitions.
- *
- * Columns default to `size: 150`, `minSize: 20`, and
- * `maxSize: Number.MAX_SAFE_INTEGER` unless overridden by column definitions or
- * table defaults.
- *
- * @example
- * ```ts
- * const defaults = getDefaultColumnSizingColumnDef()
- * ```
- */
-declare function getDefaultColumnSizingColumnDef(): {
-  size: number;
-  minSize: number;
-  maxSize: number;
-};
-/**
- * Resolves a column's current pixel size.
- *
- * 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 width = column_getSize(column)
- * ```
- */
-declare function column_getSize<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): number;
-/**
- * Builds start and after offset maps for every visible leaf column, computed
- * once per pinning region plus the full visible list.
- *
- * A single table-level memo of this result backs all `column.getStart()` and
- * `column.getAfter()` calls with O(1) lookups.
- *
- * @example
- * ```ts
- * const offsets = table_getColumnOffsets(table)
- * const startOffset = offsets.start.starts[column.id]
- * ```
- */
-declare function table_getColumnOffsets<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): ColumnOffsetsByPosition;
-/**
- * Computes the offset from the start edge of a pinning region to this column.
- *
- * The value is the sum of all previous visible leaf column sizes in the
- * requested `'start'`, `'center'`, or `'end'` region.
- *
- * `start` and `end` are logical positions. In LTR languages/layouts, `start`
- * usually corresponds to left and `end` to right. In RTL languages/layouts,
- * `start` usually corresponds to right and `end` to left.
- *
- * @example
- * ```ts
- * const startOffset = column_getStart(column, 'start')
- * ```
- */
-declare function column_getStart<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>, position?: ColumnPinningPosition | 'center'): number;
-/**
- * Computes the offset from the end edge of a pinning region after this column.
- *
- * The value is the sum of all following visible leaf column sizes in the
- * requested region.
- *
- * @example
- * ```ts
- * const endOffset = column_getAfter(column, 'end')
- * ```
- */
-declare function column_getAfter<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>, position?: ColumnPinningPosition | 'center'): number;
-/**
- * Removes this column's committed size override.
- *
- * After reset, the column resolves size from `columnDef.size` or built-in
- * defaults again.
- *
- * @example
- * ```ts
- * column_resetSize(column)
- * ```
- */
-declare function column_resetSize<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): void;
-/**
- * Computes a header's rendered size from its leaf headers.
- *
- * Group headers sum the sizes of all descendant leaf columns. Leaf headers use
- * their column's current size.
- *
- * @example
- * ```ts
- * 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;
-/**
- * Computes a header's offset from the start of its header group.
- *
- * The offset is the previous sibling header's start plus size, or `0` for the
- * first header in the group.
- *
- * @example
- * ```ts
- * 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;
-/**
- * Routes a committed column sizing updater through the table's sizing handler.
- *
- * 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, age: 96 }))
- * ```
- */
-declare function table_setColumnSizing<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, updater: Updater<ColumnSizingState>): void;
-/**
- * Resets `columnSizing` to the configured initial state or feature default.
- *
- * With no argument, the reset clones `table.initialState.columnSizing` when it
- * exists. Passing `true` ignores initial state and resets to `{}`.
- *
- * @example
- * ```ts
- * table_resetColumnSizing(table)
- * table_resetColumnSizing(table, true)
- * ```
- */
-declare function table_resetColumnSizing<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, defaultState?: boolean): void;
-/**
- * Sums the rendered size of the full table header row.
- *
- * This includes start, center, and end columns in the main header group.
- *
- * @example
- * ```ts
- * const width = table_getTotalSize(table)
- * ```
- */
-declare function table_getTotalSize<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): number;
-/**
- * Sums the rendered size of the logical start pinned header region.
- *
- * An empty start pinning region returns `0`.
- *
- * @example
- * ```ts
- * const width = table_getStartTotalSize(table)
- * ```
- */
-declare function table_getStartTotalSize<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): number;
-/**
- * Sums the rendered size of the center, unpinned header region.
- *
- * An empty center region returns `0`.
- *
- * @example
- * ```ts
- * const width = table_getCenterTotalSize(table)
- * ```
- */
-declare function table_getCenterTotalSize<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): number;
-/**
- * Sums the rendered size of the logical end pinned header region.
- *
- * An empty end pinning region returns `0`.
- *
- * @example
- * ```ts
- * const width = table_getEndTotalSize(table)
- * ```
- */
-declare function table_getEndTotalSize<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): number;
-//#endregion
-export { column_getAfter, column_getSize, column_getStart, column_resetSize, getDefaultColumnSizingColumnDef, getDefaultColumnSizingState, header_getSize, header_getStart, table_getCenterTotalSize, table_getColumnOffsets, table_getEndTotalSize, table_getStartTotalSize, table_getTotalSize, table_resetColumnSizing, table_setColumnSizing };
-//# sourceMappingURL=columnSizingFeature.utils.d.cts.map