@tanstack/table-core 9.0.0-beta.26 → 9.0.0-beta.28

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

@@ -1,5 +1,5 @@
 import { CellData, RowData, Updater } from "../../types/type-utils.cjs";
-import { ColumnSizingState } from "./columnSizingFeature.types.cjs";
+import { ColumnOffsetsByPosition, ColumnSizingState } from "./columnSizingFeature.types.cjs";
 import { Header } from "../../types/Header.cjs";
 import { ColumnPinningPosition } from "../column-pinning/columnPinningFeature.types.cjs";
 import { Table } from "../../types/Table.cjs";
@@ -48,6 +48,20 @@ declare function getDefaultColumnSizingColumnDef(): {
  * ```
  */
 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 leftOffset = offsets.left.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.
  *
@@ -59,7 +73,7 @@ declare function column_getSize<TFeatures extends TableFeatures, TData extends R
  * const leftOffset = column_getStart(column, 'left')
  * ```
  */
-declare function column_getStart<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>, position: ColumnPinningPosition | 'center'): number;
+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.
  *
@@ -71,7 +85,7 @@ declare function column_getStart<TFeatures extends TableFeatures, TData extends
  * const rightOffset = column_getAfter(column, 'right')
  * ```
  */
-declare function column_getAfter<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>, position: ColumnPinningPosition | 'center'): number;
+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.
  *
@@ -178,5 +192,5 @@ declare function table_getCenterTotalSize<TFeatures extends TableFeatures, TData
  */
 declare function table_getRightTotalSize<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_getLeftTotalSize, table_getRightTotalSize, table_getTotalSize, table_resetColumnSizing, table_setColumnSizing };
+export { column_getAfter, column_getSize, column_getStart, column_resetSize, getDefaultColumnSizingColumnDef, getDefaultColumnSizingState, header_getSize, header_getStart, table_getCenterTotalSize, table_getColumnOffsets, table_getLeftTotalSize, table_getRightTotalSize, table_getTotalSize, table_resetColumnSizing, table_setColumnSizing };
 //# sourceMappingURL=columnSizingFeature.utils.d.cts.map

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

@@ -1,5 +1,5 @@
 import { CellData, RowData, Updater } from "../../types/type-utils.js";
-import { ColumnSizingState } from "./columnSizingFeature.types.js";
+import { ColumnOffsetsByPosition, ColumnSizingState } from "./columnSizingFeature.types.js";
 import { Header } from "../../types/Header.js";
 import { ColumnPinningPosition } from "../column-pinning/columnPinningFeature.types.js";
 import { Table } from "../../types/Table.js";
@@ -48,6 +48,20 @@ declare function getDefaultColumnSizingColumnDef(): {
  * ```
  */
 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 leftOffset = offsets.left.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.
  *
@@ -59,7 +73,7 @@ declare function column_getSize<TFeatures extends TableFeatures, TData extends R
  * const leftOffset = column_getStart(column, 'left')
  * ```
  */
-declare function column_getStart<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>, position: ColumnPinningPosition | 'center'): number;
+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.
  *
@@ -71,7 +85,7 @@ declare function column_getStart<TFeatures extends TableFeatures, TData extends
  * const rightOffset = column_getAfter(column, 'right')
  * ```
  */
-declare function column_getAfter<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>, position: ColumnPinningPosition | 'center'): number;
+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.
  *
@@ -178,5 +192,5 @@ declare function table_getCenterTotalSize<TFeatures extends TableFeatures, TData
  */
 declare function table_getRightTotalSize<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_getLeftTotalSize, table_getRightTotalSize, table_getTotalSize, table_resetColumnSizing, table_setColumnSizing };
+export { column_getAfter, column_getSize, column_getStart, column_resetSize, getDefaultColumnSizingColumnDef, getDefaultColumnSizingState, header_getSize, header_getStart, table_getCenterTotalSize, table_getColumnOffsets, table_getLeftTotalSize, table_getRightTotalSize, table_getTotalSize, table_resetColumnSizing, table_setColumnSizing };
 //# sourceMappingURL=columnSizingFeature.utils.d.ts.map

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

@@ -1,6 +1,5 @@
 import { callMemoOrStaticFn, cloneState, hasOwn, makeObjectMap } from "../../utils.js";
 import { table_getCenterHeaderGroups, table_getLeftHeaderGroups, table_getPinnedVisibleLeafColumns, table_getRightHeaderGroups } from "../column-pinning/columnPinningFeature.utils.js";
-import { column_getIndex } from "../column-ordering/columnOrderingFeature.utils.js";
 
 //#region src/features/column-sizing/columnSizingFeature.utils.ts
 /**
@@ -54,6 +53,52 @@ function column_getSize(column) {
 	const columnSize = columnSizing && 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 = makeObjectMap();
+	const afters = makeObjectMap();
+	const sizes = new Array(columns.length);
+	let start = 0;
+	for (let i = 0; i < columns.length; i++) {
+		const column = columns[i];
+		const size = 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 leftOffset = offsets.left.starts[column.id]
+* ```
+*/
+function table_getColumnOffsets(table) {
+	return {
+		all: buildColumnOffsets(table_getPinnedVisibleLeafColumns(table)),
+		center: buildColumnOffsets(table_getPinnedVisibleLeafColumns(table, "center")),
+		left: buildColumnOffsets(table_getPinnedVisibleLeafColumns(table, "left")),
+		right: buildColumnOffsets(table_getPinnedVisibleLeafColumns(table, "right"))
+	};
+}
+function toOffsetsKey(position) {
+	return position === "left" ? "left" : position === "right" ? "right" : position === "center" ? "center" : "all";
+}
 /**
 * Computes the offset from the start edge of a pinning region to this column.
 *
@@ -66,10 +111,7 @@ function column_getSize(column) {
 * ```
 */
 function column_getStart(column, position) {
-	const index = callMemoOrStaticFn(column, "getIndex", column_getIndex, position);
-	if (index <= 0) return 0;
-	const prevColumn = callMemoOrStaticFn(column.table, "getPinnedVisibleLeafColumns", table_getPinnedVisibleLeafColumns, position)[index - 1];
-	return callMemoOrStaticFn(prevColumn, "getStart", column_getStart, position) + callMemoOrStaticFn(prevColumn, "getSize", column_getSize);
+	return 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.
@@ -83,11 +125,7 @@ function column_getStart(column, position) {
 * ```
 */
 function column_getAfter(column, position) {
-	const visibleLeafColumns = callMemoOrStaticFn(column.table, "getPinnedVisibleLeafColumns", table_getPinnedVisibleLeafColumns, position);
-	const index = callMemoOrStaticFn(column, "getIndex", column_getIndex, position);
-	if (index < 0 || index >= visibleLeafColumns.length - 1) return 0;
-	const nextColumn = visibleLeafColumns[index + 1];
-	return callMemoOrStaticFn(nextColumn, "getSize", column_getSize) + callMemoOrStaticFn(nextColumn, "getAfter", column_getAfter, position);
+	return callMemoOrStaticFn(column.table, "getColumnOffsets", table_getColumnOffsets)[toOffsetsKey(position)].afters[column.id] ?? 0;
 }
 /**
 * Removes this column's committed size override.
@@ -246,5 +284,5 @@ function table_getRightTotalSize(table) {
 }
 
 //#endregion
-export { column_getAfter, column_getSize, column_getStart, column_resetSize, getDefaultColumnSizingColumnDef, getDefaultColumnSizingState, header_getSize, header_getStart, table_getCenterTotalSize, table_getLeftTotalSize, table_getRightTotalSize, table_getTotalSize, table_resetColumnSizing, table_setColumnSizing };
+export { column_getAfter, column_getSize, column_getStart, column_resetSize, getDefaultColumnSizingColumnDef, getDefaultColumnSizingState, header_getSize, header_getStart, table_getCenterTotalSize, table_getColumnOffsets, table_getLeftTotalSize, table_getRightTotalSize, table_getTotalSize, table_resetColumnSizing, table_setColumnSizing };
 //# sourceMappingURL=columnSizingFeature.utils.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"columnSizingFeature.utils.js","names":[],"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 {\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 { 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 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\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, (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 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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"}
+{"version":3,"file":"columnSizingFeature.utils.js","names":[],"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 {\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 leftOffset = offsets.left.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    left: buildColumnOffsets(\n      table_getPinnedVisibleLeafColumns(table, 'left') as Array<\n        Column_Internal<TFeatures, TData, unknown>\n      >,\n    ),\n    right: buildColumnOffsets(\n      table_getPinnedVisibleLeafColumns(table, 'right') 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 === 'left'\n    ? 'left'\n    : position === 'right'\n      ? 'right'\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 `'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 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 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 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 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-visibility/columnVisibilityFeature.cjs

@@ -60,22 +60,26 @@ const columnVisibilityFeature = {
 			table_getVisibleFlatColumns: {
 				fn: () => require_columnVisibilityFeature_utils.table_getVisibleFlatColumns(table),
 				memoDeps: () => {
-					var _table$atoms$columnVi4, _table$atoms$columnOr;
+					var _table$atoms$columnVi4, _table$atoms$columnOr, _table$atoms$grouping;
 					return [
 						(_table$atoms$columnVi4 = table.atoms.columnVisibility) === null || _table$atoms$columnVi4 === void 0 ? void 0 : _table$atoms$columnVi4.get(),
 						(_table$atoms$columnOr = table.atoms.columnOrder) === null || _table$atoms$columnOr === void 0 ? void 0 : _table$atoms$columnOr.get(),
-						table.options.columns
+						(_table$atoms$grouping = table.atoms.grouping) === null || _table$atoms$grouping === void 0 ? void 0 : _table$atoms$grouping.get(),
+						table.options.columns,
+						table.options.groupedColumnMode
 					];
 				}
 			},
 			table_getVisibleLeafColumns: {
 				fn: () => require_columnVisibilityFeature_utils.table_getVisibleLeafColumns(table),
 				memoDeps: () => {
-					var _table$atoms$columnVi5, _table$atoms$columnOr2;
+					var _table$atoms$columnVi5, _table$atoms$columnOr2, _table$atoms$grouping2;
 					return [
 						(_table$atoms$columnVi5 = table.atoms.columnVisibility) === null || _table$atoms$columnVi5 === void 0 ? void 0 : _table$atoms$columnVi5.get(),
 						(_table$atoms$columnOr2 = table.atoms.columnOrder) === null || _table$atoms$columnOr2 === void 0 ? void 0 : _table$atoms$columnOr2.get(),
-						table.options.columns
+						(_table$atoms$grouping2 = table.atoms.grouping) === null || _table$atoms$grouping2 === void 0 ? void 0 : _table$atoms$grouping2.get(),
+						table.options.columns,
+						table.options.groupedColumnMode
 					];
 				}
 			},

package/dist/features/column-visibility/columnVisibilityFeature.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"columnVisibilityFeature.cjs","names":["getDefaultColumnVisibilityState","makeStateUpdater","column_getIsVisible","column_getCanHide","column_getToggleVisibilityHandler","column_toggleVisibility","row_getVisibleCells","row_getVisibleCellsByColumnId","table_getVisibleFlatColumns","table_getVisibleLeafColumns","table_setColumnVisibility","table_resetColumnVisibility","table_toggleAllColumnsVisible","table_getIsAllColumnsVisible","table_getIsSomeColumnsVisible","table_getToggleAllColumnsVisibilityHandler"],"sources":["../../../src/features/column-visibility/columnVisibilityFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  column_getCanHide,\n  column_getIsVisible,\n  column_getToggleVisibilityHandler,\n  column_toggleVisibility,\n  getDefaultColumnVisibilityState,\n  row_getVisibleCells,\n  row_getVisibleCellsByColumnId,\n  table_getIsAllColumnsVisible,\n  table_getIsSomeColumnsVisible,\n  table_getToggleAllColumnsVisibilityHandler,\n  table_getVisibleFlatColumns,\n  table_getVisibleLeafColumns,\n  table_resetColumnVisibility,\n  table_setColumnVisibility,\n  table_toggleAllColumnsVisible,\n} from './columnVisibilityFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Feature that adds column visibility state and APIs for hiding and showing columns.\n */\nexport const columnVisibilityFeature: TableFeature = {\n  getInitialState: (initialState) => {\n    return {\n      columnVisibility: getDefaultColumnVisibilityState(),\n      ...initialState,\n    }\n  },\n\n  getDefaultTableOptions: (table) => {\n    return {\n      onColumnVisibilityChange: makeStateUpdater('columnVisibility', table),\n    }\n  },\n\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {\n      column_getIsVisible: {\n        fn: (column) => column_getIsVisible(column),\n        memoDeps: (column) => [\n          table.options.columns,\n          table.atoms.columnVisibility?.get(),\n          column.columns,\n        ],\n      },\n      column_getCanHide: {\n        fn: (column) => column_getCanHide(column),\n      },\n      column_getToggleVisibilityHandler: {\n        fn: (column) => column_getToggleVisibilityHandler(column),\n      },\n      column_toggleVisibility: {\n        fn: (column, visible) => column_toggleVisibility(column, visible),\n      },\n    })\n  },\n\n  assignRowPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {\n      row_getVisibleCells: {\n        fn: (row) => row_getVisibleCells(row),\n        memoDeps: (row) => [\n          row.getAllCells(),\n          table.atoms.columnPinning?.get(),\n          table.atoms.columnVisibility?.get(),\n        ],\n      },\n      row_getVisibleCellsByColumnId: {\n        fn: (row) => row_getVisibleCellsByColumnId(row),\n        memoDeps: (row) => [\n          row.getAllCells(),\n          table.atoms.columnVisibility?.get(),\n        ],\n      },\n    })\n  },\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('columnVisibilityFeature', table, {\n      table_getVisibleFlatColumns: {\n        fn: () => table_getVisibleFlatColumns(table),\n        memoDeps: () => [\n          table.atoms.columnVisibility?.get(),\n          table.atoms.columnOrder?.get(),\n          table.options.columns,\n        ],\n      },\n      table_getVisibleLeafColumns: {\n        fn: () => table_getVisibleLeafColumns(table),\n        memoDeps: () => [\n          table.atoms.columnVisibility?.get(),\n          table.atoms.columnOrder?.get(),\n          table.options.columns,\n        ],\n      },\n      table_setColumnVisibility: {\n        fn: (updater) => table_setColumnVisibility(table, updater),\n      },\n      table_resetColumnVisibility: {\n        fn: (defaultState) => table_resetColumnVisibility(table, defaultState),\n      },\n      table_toggleAllColumnsVisible: {\n        fn: (value) => table_toggleAllColumnsVisible(table, value),\n      },\n      table_getIsAllColumnsVisible: {\n        fn: () => table_getIsAllColumnsVisible(table),\n      },\n      table_getIsSomeColumnsVisible: {\n        fn: () => table_getIsSomeColumnsVisible(table),\n      },\n      table_getToggleAllColumnsVisibilityHandler: {\n        fn: () => table_getToggleAllColumnsVisibilityHandler(table),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AA2BA,MAAa,0BAAwC;CACnD,kBAAkB,iBAAiB;EACjC,OAAO;GACL,kBAAkBA,sEAAgC;GAClD,GAAG;EACL;CACF;CAEA,yBAAyB,UAAU;EACjC,OAAO,EACL,0BAA0BC,+BAAiB,oBAAoB,KAAK,EACtE;CACF;CAEA,wBAAwB,WAAW,UAAU;EAC3C,kCAAoB,2BAA2B,WAAW,OAAO;GAC/D,qBAAqB;IACnB,KAAK,WAAWC,0DAAoB,MAAM;IAC1C,WAAW,WAAW;;;MACpB,MAAM,QAAQ;+BACd,MAAM,MAAM,gGAAkB,IAAI;MAClC,OAAO;KACT;;GACF;GACA,mBAAmB,EACjB,KAAK,WAAWC,wDAAkB,MAAM,EAC1C;GACA,mCAAmC,EACjC,KAAK,WAAWC,wEAAkC,MAAM,EAC1D;GACA,yBAAyB,EACvB,KAAK,QAAQ,YAAYC,8DAAwB,QAAQ,OAAO,EAClE;EACF,CAAC;CACH;CAEA,qBAAqB,WAAW,UAAU;EACxC,kCAAoB,2BAA2B,WAAW,OAAO;GAC/D,qBAAqB;IACnB,KAAK,QAAQC,0DAAoB,GAAG;IACpC,WAAW,QAAQ;;;MACjB,IAAI,YAAY;+BAChB,MAAM,MAAM,6FAAe,IAAI;gCAC/B,MAAM,MAAM,kGAAkB,IAAI;KACpC;;GACF;GACA,+BAA+B;IAC7B,KAAK,QAAQC,oEAA8B,GAAG;IAC9C,WAAW,QAAQ;;aACjB,IAAI,YAAY,6BAChB,MAAM,MAAM,kGAAkB,IAAI,CACpC;;GACF;EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,8BAAgB,2BAA2B,OAAO;GAChD,6BAA6B;IAC3B,UAAUC,kEAA4B,KAAK;IAC3C,gBAAgB;;;gCACd,MAAM,MAAM,kGAAkB,IAAI;+BAClC,MAAM,MAAM,2FAAa,IAAI;MAC7B,MAAM,QAAQ;KAChB;;GACF;GACA,6BAA6B;IAC3B,UAAUC,kEAA4B,KAAK;IAC3C,gBAAgB;;;gCACd,MAAM,MAAM,kGAAkB,IAAI;gCAClC,MAAM,MAAM,6FAAa,IAAI;MAC7B,MAAM,QAAQ;KAChB;;GACF;GACA,2BAA2B,EACzB,KAAK,YAAYC,gEAA0B,OAAO,OAAO,EAC3D;GACA,6BAA6B,EAC3B,KAAK,iBAAiBC,kEAA4B,OAAO,YAAY,EACvE;GACA,+BAA+B,EAC7B,KAAK,UAAUC,oEAA8B,OAAO,KAAK,EAC3D;GACA,8BAA8B,EAC5B,UAAUC,mEAA6B,KAAK,EAC9C;GACA,+BAA+B,EAC7B,UAAUC,oEAA8B,KAAK,EAC/C;GACA,4CAA4C,EAC1C,UAAUC,iFAA2C,KAAK,EAC5D;EACF,CAAC;CACH;AACF"}
+{"version":3,"file":"columnVisibilityFeature.cjs","names":["getDefaultColumnVisibilityState","makeStateUpdater","column_getIsVisible","column_getCanHide","column_getToggleVisibilityHandler","column_toggleVisibility","row_getVisibleCells","row_getVisibleCellsByColumnId","table_getVisibleFlatColumns","table_getVisibleLeafColumns","table_setColumnVisibility","table_resetColumnVisibility","table_toggleAllColumnsVisible","table_getIsAllColumnsVisible","table_getIsSomeColumnsVisible","table_getToggleAllColumnsVisibilityHandler"],"sources":["../../../src/features/column-visibility/columnVisibilityFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  column_getCanHide,\n  column_getIsVisible,\n  column_getToggleVisibilityHandler,\n  column_toggleVisibility,\n  getDefaultColumnVisibilityState,\n  row_getVisibleCells,\n  row_getVisibleCellsByColumnId,\n  table_getIsAllColumnsVisible,\n  table_getIsSomeColumnsVisible,\n  table_getToggleAllColumnsVisibilityHandler,\n  table_getVisibleFlatColumns,\n  table_getVisibleLeafColumns,\n  table_resetColumnVisibility,\n  table_setColumnVisibility,\n  table_toggleAllColumnsVisible,\n} from './columnVisibilityFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Feature that adds column visibility state and APIs for hiding and showing columns.\n */\nexport const columnVisibilityFeature: TableFeature = {\n  getInitialState: (initialState) => {\n    return {\n      columnVisibility: getDefaultColumnVisibilityState(),\n      ...initialState,\n    }\n  },\n\n  getDefaultTableOptions: (table) => {\n    return {\n      onColumnVisibilityChange: makeStateUpdater('columnVisibility', table),\n    }\n  },\n\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {\n      column_getIsVisible: {\n        fn: (column) => column_getIsVisible(column),\n        memoDeps: (column) => [\n          table.options.columns,\n          table.atoms.columnVisibility?.get(),\n          column.columns,\n        ],\n      },\n      column_getCanHide: {\n        fn: (column) => column_getCanHide(column),\n      },\n      column_getToggleVisibilityHandler: {\n        fn: (column) => column_getToggleVisibilityHandler(column),\n      },\n      column_toggleVisibility: {\n        fn: (column, visible) => column_toggleVisibility(column, visible),\n      },\n    })\n  },\n\n  assignRowPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {\n      row_getVisibleCells: {\n        fn: (row) => row_getVisibleCells(row),\n        memoDeps: (row) => [\n          row.getAllCells(),\n          table.atoms.columnPinning?.get(),\n          table.atoms.columnVisibility?.get(),\n        ],\n      },\n      row_getVisibleCellsByColumnId: {\n        fn: (row) => row_getVisibleCellsByColumnId(row),\n        memoDeps: (row) => [\n          row.getAllCells(),\n          table.atoms.columnVisibility?.get(),\n        ],\n      },\n    })\n  },\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('columnVisibilityFeature', table, {\n      table_getVisibleFlatColumns: {\n        fn: () => table_getVisibleFlatColumns(table),\n        memoDeps: () => [\n          table.atoms.columnVisibility?.get(),\n          table.atoms.columnOrder?.get(),\n          table.atoms.grouping?.get(),\n          table.options.columns,\n          table.options.groupedColumnMode,\n        ],\n      },\n      table_getVisibleLeafColumns: {\n        fn: () => table_getVisibleLeafColumns(table),\n        memoDeps: () => [\n          table.atoms.columnVisibility?.get(),\n          table.atoms.columnOrder?.get(),\n          table.atoms.grouping?.get(),\n          table.options.columns,\n          table.options.groupedColumnMode,\n        ],\n      },\n      table_setColumnVisibility: {\n        fn: (updater) => table_setColumnVisibility(table, updater),\n      },\n      table_resetColumnVisibility: {\n        fn: (defaultState) => table_resetColumnVisibility(table, defaultState),\n      },\n      table_toggleAllColumnsVisible: {\n        fn: (value) => table_toggleAllColumnsVisible(table, value),\n      },\n      table_getIsAllColumnsVisible: {\n        fn: () => table_getIsAllColumnsVisible(table),\n      },\n      table_getIsSomeColumnsVisible: {\n        fn: () => table_getIsSomeColumnsVisible(table),\n      },\n      table_getToggleAllColumnsVisibilityHandler: {\n        fn: () => table_getToggleAllColumnsVisibilityHandler(table),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AA2BA,MAAa,0BAAwC;CACnD,kBAAkB,iBAAiB;EACjC,OAAO;GACL,kBAAkBA,sEAAgC;GAClD,GAAG;EACL;CACF;CAEA,yBAAyB,UAAU;EACjC,OAAO,EACL,0BAA0BC,+BAAiB,oBAAoB,KAAK,EACtE;CACF;CAEA,wBAAwB,WAAW,UAAU;EAC3C,kCAAoB,2BAA2B,WAAW,OAAO;GAC/D,qBAAqB;IACnB,KAAK,WAAWC,0DAAoB,MAAM;IAC1C,WAAW,WAAW;;;MACpB,MAAM,QAAQ;+BACd,MAAM,MAAM,gGAAkB,IAAI;MAClC,OAAO;KACT;;GACF;GACA,mBAAmB,EACjB,KAAK,WAAWC,wDAAkB,MAAM,EAC1C;GACA,mCAAmC,EACjC,KAAK,WAAWC,wEAAkC,MAAM,EAC1D;GACA,yBAAyB,EACvB,KAAK,QAAQ,YAAYC,8DAAwB,QAAQ,OAAO,EAClE;EACF,CAAC;CACH;CAEA,qBAAqB,WAAW,UAAU;EACxC,kCAAoB,2BAA2B,WAAW,OAAO;GAC/D,qBAAqB;IACnB,KAAK,QAAQC,0DAAoB,GAAG;IACpC,WAAW,QAAQ;;;MACjB,IAAI,YAAY;+BAChB,MAAM,MAAM,6FAAe,IAAI;gCAC/B,MAAM,MAAM,kGAAkB,IAAI;KACpC;;GACF;GACA,+BAA+B;IAC7B,KAAK,QAAQC,oEAA8B,GAAG;IAC9C,WAAW,QAAQ;;aACjB,IAAI,YAAY,6BAChB,MAAM,MAAM,kGAAkB,IAAI,CACpC;;GACF;EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,8BAAgB,2BAA2B,OAAO;GAChD,6BAA6B;IAC3B,UAAUC,kEAA4B,KAAK;IAC3C,gBAAgB;;;gCACd,MAAM,MAAM,kGAAkB,IAAI;+BAClC,MAAM,MAAM,2FAAa,IAAI;+BAC7B,MAAM,MAAM,wFAAU,IAAI;MAC1B,MAAM,QAAQ;MACd,MAAM,QAAQ;KAChB;;GACF;GACA,6BAA6B;IAC3B,UAAUC,kEAA4B,KAAK;IAC3C,gBAAgB;;;gCACd,MAAM,MAAM,kGAAkB,IAAI;gCAClC,MAAM,MAAM,6FAAa,IAAI;gCAC7B,MAAM,MAAM,0FAAU,IAAI;MAC1B,MAAM,QAAQ;MACd,MAAM,QAAQ;KAChB;;GACF;GACA,2BAA2B,EACzB,KAAK,YAAYC,gEAA0B,OAAO,OAAO,EAC3D;GACA,6BAA6B,EAC3B,KAAK,iBAAiBC,kEAA4B,OAAO,YAAY,EACvE;GACA,+BAA+B,EAC7B,KAAK,UAAUC,oEAA8B,OAAO,KAAK,EAC3D;GACA,8BAA8B,EAC5B,UAAUC,mEAA6B,KAAK,EAC9C;GACA,+BAA+B,EAC7B,UAAUC,oEAA8B,KAAK,EAC/C;GACA,4CAA4C,EAC1C,UAAUC,iFAA2C,KAAK,EAC5D;EACF,CAAC;CACH;AACF"}

package/dist/features/column-visibility/columnVisibilityFeature.js

@@ -60,22 +60,26 @@ const columnVisibilityFeature = {
 			table_getVisibleFlatColumns: {
 				fn: () => table_getVisibleFlatColumns(table),
 				memoDeps: () => {
-					var _table$atoms$columnVi4, _table$atoms$columnOr;
+					var _table$atoms$columnVi4, _table$atoms$columnOr, _table$atoms$grouping;
 					return [
 						(_table$atoms$columnVi4 = table.atoms.columnVisibility) === null || _table$atoms$columnVi4 === void 0 ? void 0 : _table$atoms$columnVi4.get(),
 						(_table$atoms$columnOr = table.atoms.columnOrder) === null || _table$atoms$columnOr === void 0 ? void 0 : _table$atoms$columnOr.get(),
-						table.options.columns
+						(_table$atoms$grouping = table.atoms.grouping) === null || _table$atoms$grouping === void 0 ? void 0 : _table$atoms$grouping.get(),
+						table.options.columns,
+						table.options.groupedColumnMode
 					];
 				}
 			},
 			table_getVisibleLeafColumns: {
 				fn: () => table_getVisibleLeafColumns(table),
 				memoDeps: () => {
-					var _table$atoms$columnVi5, _table$atoms$columnOr2;
+					var _table$atoms$columnVi5, _table$atoms$columnOr2, _table$atoms$grouping2;
 					return [
 						(_table$atoms$columnVi5 = table.atoms.columnVisibility) === null || _table$atoms$columnVi5 === void 0 ? void 0 : _table$atoms$columnVi5.get(),
 						(_table$atoms$columnOr2 = table.atoms.columnOrder) === null || _table$atoms$columnOr2 === void 0 ? void 0 : _table$atoms$columnOr2.get(),
-						table.options.columns
+						(_table$atoms$grouping2 = table.atoms.grouping) === null || _table$atoms$grouping2 === void 0 ? void 0 : _table$atoms$grouping2.get(),
+						table.options.columns,
+						table.options.groupedColumnMode
 					];
 				}
 			},

package/dist/features/column-visibility/columnVisibilityFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"columnVisibilityFeature.js","names":[],"sources":["../../../src/features/column-visibility/columnVisibilityFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  column_getCanHide,\n  column_getIsVisible,\n  column_getToggleVisibilityHandler,\n  column_toggleVisibility,\n  getDefaultColumnVisibilityState,\n  row_getVisibleCells,\n  row_getVisibleCellsByColumnId,\n  table_getIsAllColumnsVisible,\n  table_getIsSomeColumnsVisible,\n  table_getToggleAllColumnsVisibilityHandler,\n  table_getVisibleFlatColumns,\n  table_getVisibleLeafColumns,\n  table_resetColumnVisibility,\n  table_setColumnVisibility,\n  table_toggleAllColumnsVisible,\n} from './columnVisibilityFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Feature that adds column visibility state and APIs for hiding and showing columns.\n */\nexport const columnVisibilityFeature: TableFeature = {\n  getInitialState: (initialState) => {\n    return {\n      columnVisibility: getDefaultColumnVisibilityState(),\n      ...initialState,\n    }\n  },\n\n  getDefaultTableOptions: (table) => {\n    return {\n      onColumnVisibilityChange: makeStateUpdater('columnVisibility', table),\n    }\n  },\n\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {\n      column_getIsVisible: {\n        fn: (column) => column_getIsVisible(column),\n        memoDeps: (column) => [\n          table.options.columns,\n          table.atoms.columnVisibility?.get(),\n          column.columns,\n        ],\n      },\n      column_getCanHide: {\n        fn: (column) => column_getCanHide(column),\n      },\n      column_getToggleVisibilityHandler: {\n        fn: (column) => column_getToggleVisibilityHandler(column),\n      },\n      column_toggleVisibility: {\n        fn: (column, visible) => column_toggleVisibility(column, visible),\n      },\n    })\n  },\n\n  assignRowPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {\n      row_getVisibleCells: {\n        fn: (row) => row_getVisibleCells(row),\n        memoDeps: (row) => [\n          row.getAllCells(),\n          table.atoms.columnPinning?.get(),\n          table.atoms.columnVisibility?.get(),\n        ],\n      },\n      row_getVisibleCellsByColumnId: {\n        fn: (row) => row_getVisibleCellsByColumnId(row),\n        memoDeps: (row) => [\n          row.getAllCells(),\n          table.atoms.columnVisibility?.get(),\n        ],\n      },\n    })\n  },\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('columnVisibilityFeature', table, {\n      table_getVisibleFlatColumns: {\n        fn: () => table_getVisibleFlatColumns(table),\n        memoDeps: () => [\n          table.atoms.columnVisibility?.get(),\n          table.atoms.columnOrder?.get(),\n          table.options.columns,\n        ],\n      },\n      table_getVisibleLeafColumns: {\n        fn: () => table_getVisibleLeafColumns(table),\n        memoDeps: () => [\n          table.atoms.columnVisibility?.get(),\n          table.atoms.columnOrder?.get(),\n          table.options.columns,\n        ],\n      },\n      table_setColumnVisibility: {\n        fn: (updater) => table_setColumnVisibility(table, updater),\n      },\n      table_resetColumnVisibility: {\n        fn: (defaultState) => table_resetColumnVisibility(table, defaultState),\n      },\n      table_toggleAllColumnsVisible: {\n        fn: (value) => table_toggleAllColumnsVisible(table, value),\n      },\n      table_getIsAllColumnsVisible: {\n        fn: () => table_getIsAllColumnsVisible(table),\n      },\n      table_getIsSomeColumnsVisible: {\n        fn: () => table_getIsSomeColumnsVisible(table),\n      },\n      table_getToggleAllColumnsVisibilityHandler: {\n        fn: () => table_getToggleAllColumnsVisibilityHandler(table),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AA2BA,MAAa,0BAAwC;CACnD,kBAAkB,iBAAiB;EACjC,OAAO;GACL,kBAAkB,gCAAgC;GAClD,GAAG;EACL;CACF;CAEA,yBAAyB,UAAU;EACjC,OAAO,EACL,0BAA0B,iBAAiB,oBAAoB,KAAK,EACtE;CACF;CAEA,wBAAwB,WAAW,UAAU;EAC3C,oBAAoB,2BAA2B,WAAW,OAAO;GAC/D,qBAAqB;IACnB,KAAK,WAAW,oBAAoB,MAAM;IAC1C,WAAW,WAAW;;;MACpB,MAAM,QAAQ;+BACd,MAAM,MAAM,gGAAkB,IAAI;MAClC,OAAO;KACT;;GACF;GACA,mBAAmB,EACjB,KAAK,WAAW,kBAAkB,MAAM,EAC1C;GACA,mCAAmC,EACjC,KAAK,WAAW,kCAAkC,MAAM,EAC1D;GACA,yBAAyB,EACvB,KAAK,QAAQ,YAAY,wBAAwB,QAAQ,OAAO,EAClE;EACF,CAAC;CACH;CAEA,qBAAqB,WAAW,UAAU;EACxC,oBAAoB,2BAA2B,WAAW,OAAO;GAC/D,qBAAqB;IACnB,KAAK,QAAQ,oBAAoB,GAAG;IACpC,WAAW,QAAQ;;;MACjB,IAAI,YAAY;+BAChB,MAAM,MAAM,6FAAe,IAAI;gCAC/B,MAAM,MAAM,kGAAkB,IAAI;KACpC;;GACF;GACA,+BAA+B;IAC7B,KAAK,QAAQ,8BAA8B,GAAG;IAC9C,WAAW,QAAQ;;aACjB,IAAI,YAAY,6BAChB,MAAM,MAAM,kGAAkB,IAAI,CACpC;;GACF;EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,gBAAgB,2BAA2B,OAAO;GAChD,6BAA6B;IAC3B,UAAU,4BAA4B,KAAK;IAC3C,gBAAgB;;;gCACd,MAAM,MAAM,kGAAkB,IAAI;+BAClC,MAAM,MAAM,2FAAa,IAAI;MAC7B,MAAM,QAAQ;KAChB;;GACF;GACA,6BAA6B;IAC3B,UAAU,4BAA4B,KAAK;IAC3C,gBAAgB;;;gCACd,MAAM,MAAM,kGAAkB,IAAI;gCAClC,MAAM,MAAM,6FAAa,IAAI;MAC7B,MAAM,QAAQ;KAChB;;GACF;GACA,2BAA2B,EACzB,KAAK,YAAY,0BAA0B,OAAO,OAAO,EAC3D;GACA,6BAA6B,EAC3B,KAAK,iBAAiB,4BAA4B,OAAO,YAAY,EACvE;GACA,+BAA+B,EAC7B,KAAK,UAAU,8BAA8B,OAAO,KAAK,EAC3D;GACA,8BAA8B,EAC5B,UAAU,6BAA6B,KAAK,EAC9C;GACA,+BAA+B,EAC7B,UAAU,8BAA8B,KAAK,EAC/C;GACA,4CAA4C,EAC1C,UAAU,2CAA2C,KAAK,EAC5D;EACF,CAAC;CACH;AACF"}
+{"version":3,"file":"columnVisibilityFeature.js","names":[],"sources":["../../../src/features/column-visibility/columnVisibilityFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  column_getCanHide,\n  column_getIsVisible,\n  column_getToggleVisibilityHandler,\n  column_toggleVisibility,\n  getDefaultColumnVisibilityState,\n  row_getVisibleCells,\n  row_getVisibleCellsByColumnId,\n  table_getIsAllColumnsVisible,\n  table_getIsSomeColumnsVisible,\n  table_getToggleAllColumnsVisibilityHandler,\n  table_getVisibleFlatColumns,\n  table_getVisibleLeafColumns,\n  table_resetColumnVisibility,\n  table_setColumnVisibility,\n  table_toggleAllColumnsVisible,\n} from './columnVisibilityFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Feature that adds column visibility state and APIs for hiding and showing columns.\n */\nexport const columnVisibilityFeature: TableFeature = {\n  getInitialState: (initialState) => {\n    return {\n      columnVisibility: getDefaultColumnVisibilityState(),\n      ...initialState,\n    }\n  },\n\n  getDefaultTableOptions: (table) => {\n    return {\n      onColumnVisibilityChange: makeStateUpdater('columnVisibility', table),\n    }\n  },\n\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {\n      column_getIsVisible: {\n        fn: (column) => column_getIsVisible(column),\n        memoDeps: (column) => [\n          table.options.columns,\n          table.atoms.columnVisibility?.get(),\n          column.columns,\n        ],\n      },\n      column_getCanHide: {\n        fn: (column) => column_getCanHide(column),\n      },\n      column_getToggleVisibilityHandler: {\n        fn: (column) => column_getToggleVisibilityHandler(column),\n      },\n      column_toggleVisibility: {\n        fn: (column, visible) => column_toggleVisibility(column, visible),\n      },\n    })\n  },\n\n  assignRowPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {\n      row_getVisibleCells: {\n        fn: (row) => row_getVisibleCells(row),\n        memoDeps: (row) => [\n          row.getAllCells(),\n          table.atoms.columnPinning?.get(),\n          table.atoms.columnVisibility?.get(),\n        ],\n      },\n      row_getVisibleCellsByColumnId: {\n        fn: (row) => row_getVisibleCellsByColumnId(row),\n        memoDeps: (row) => [\n          row.getAllCells(),\n          table.atoms.columnVisibility?.get(),\n        ],\n      },\n    })\n  },\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('columnVisibilityFeature', table, {\n      table_getVisibleFlatColumns: {\n        fn: () => table_getVisibleFlatColumns(table),\n        memoDeps: () => [\n          table.atoms.columnVisibility?.get(),\n          table.atoms.columnOrder?.get(),\n          table.atoms.grouping?.get(),\n          table.options.columns,\n          table.options.groupedColumnMode,\n        ],\n      },\n      table_getVisibleLeafColumns: {\n        fn: () => table_getVisibleLeafColumns(table),\n        memoDeps: () => [\n          table.atoms.columnVisibility?.get(),\n          table.atoms.columnOrder?.get(),\n          table.atoms.grouping?.get(),\n          table.options.columns,\n          table.options.groupedColumnMode,\n        ],\n      },\n      table_setColumnVisibility: {\n        fn: (updater) => table_setColumnVisibility(table, updater),\n      },\n      table_resetColumnVisibility: {\n        fn: (defaultState) => table_resetColumnVisibility(table, defaultState),\n      },\n      table_toggleAllColumnsVisible: {\n        fn: (value) => table_toggleAllColumnsVisible(table, value),\n      },\n      table_getIsAllColumnsVisible: {\n        fn: () => table_getIsAllColumnsVisible(table),\n      },\n      table_getIsSomeColumnsVisible: {\n        fn: () => table_getIsSomeColumnsVisible(table),\n      },\n      table_getToggleAllColumnsVisibilityHandler: {\n        fn: () => table_getToggleAllColumnsVisibilityHandler(table),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AA2BA,MAAa,0BAAwC;CACnD,kBAAkB,iBAAiB;EACjC,OAAO;GACL,kBAAkB,gCAAgC;GAClD,GAAG;EACL;CACF;CAEA,yBAAyB,UAAU;EACjC,OAAO,EACL,0BAA0B,iBAAiB,oBAAoB,KAAK,EACtE;CACF;CAEA,wBAAwB,WAAW,UAAU;EAC3C,oBAAoB,2BAA2B,WAAW,OAAO;GAC/D,qBAAqB;IACnB,KAAK,WAAW,oBAAoB,MAAM;IAC1C,WAAW,WAAW;;;MACpB,MAAM,QAAQ;+BACd,MAAM,MAAM,gGAAkB,IAAI;MAClC,OAAO;KACT;;GACF;GACA,mBAAmB,EACjB,KAAK,WAAW,kBAAkB,MAAM,EAC1C;GACA,mCAAmC,EACjC,KAAK,WAAW,kCAAkC,MAAM,EAC1D;GACA,yBAAyB,EACvB,KAAK,QAAQ,YAAY,wBAAwB,QAAQ,OAAO,EAClE;EACF,CAAC;CACH;CAEA,qBAAqB,WAAW,UAAU;EACxC,oBAAoB,2BAA2B,WAAW,OAAO;GAC/D,qBAAqB;IACnB,KAAK,QAAQ,oBAAoB,GAAG;IACpC,WAAW,QAAQ;;;MACjB,IAAI,YAAY;+BAChB,MAAM,MAAM,6FAAe,IAAI;gCAC/B,MAAM,MAAM,kGAAkB,IAAI;KACpC;;GACF;GACA,+BAA+B;IAC7B,KAAK,QAAQ,8BAA8B,GAAG;IAC9C,WAAW,QAAQ;;aACjB,IAAI,YAAY,6BAChB,MAAM,MAAM,kGAAkB,IAAI,CACpC;;GACF;EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,gBAAgB,2BAA2B,OAAO;GAChD,6BAA6B;IAC3B,UAAU,4BAA4B,KAAK;IAC3C,gBAAgB;;;gCACd,MAAM,MAAM,kGAAkB,IAAI;+BAClC,MAAM,MAAM,2FAAa,IAAI;+BAC7B,MAAM,MAAM,wFAAU,IAAI;MAC1B,MAAM,QAAQ;MACd,MAAM,QAAQ;KAChB;;GACF;GACA,6BAA6B;IAC3B,UAAU,4BAA4B,KAAK;IAC3C,gBAAgB;;;gCACd,MAAM,MAAM,kGAAkB,IAAI;gCAClC,MAAM,MAAM,6FAAa,IAAI;gCAC7B,MAAM,MAAM,0FAAU,IAAI;MAC1B,MAAM,QAAQ;MACd,MAAM,QAAQ;KAChB;;GACF;GACA,2BAA2B,EACzB,KAAK,YAAY,0BAA0B,OAAO,OAAO,EAC3D;GACA,6BAA6B,EAC3B,KAAK,iBAAiB,4BAA4B,OAAO,YAAY,EACvE;GACA,+BAA+B,EAC7B,KAAK,UAAU,8BAA8B,OAAO,KAAK,EAC3D;GACA,8BAA8B,EAC5B,UAAU,6BAA6B,KAAK,EAC9C;GACA,+BAA+B,EAC7B,UAAU,8BAA8B,KAAK,EAC/C;GACA,4CAA4C,EAC1C,UAAU,2CAA2C,KAAK,EAC5D;EACF,CAAC;CACH;AACF"}

package/dist/features/column-visibility/columnVisibilityFeature.utils.cjs

@@ -48,10 +48,11 @@ function column_toggleVisibility(column, visible) {
 */
 function column_getIsVisible(column) {
 	var _column$table$atoms$c;
+	const columnVisibility = (_column$table$atoms$c = column.table.atoms.columnVisibility) === null || _column$table$atoms$c === void 0 ? void 0 : _column$table$atoms$c.get();
+	if (!columnVisibility) return true;
 	const childColumns = column.columns;
 	if (childColumns.length) return childColumns.some((childColumn) => require_utils.callMemoOrStaticFn(childColumn, "getIsVisible", column_getIsVisible));
-	const columnVisibility = (_column$table$atoms$c = column.table.atoms.columnVisibility) === null || _column$table$atoms$c === void 0 ? void 0 : _column$table$atoms$c.get();
-	return (columnVisibility && require_utils.hasOwn(columnVisibility, column.id) ? columnVisibility[column.id] : void 0) ?? true;
+	return (require_utils.hasOwn(columnVisibility, column.id) ? columnVisibility[column.id] : void 0) ?? true;
 }
 /**
 * Checks whether this column is allowed to be hidden.

package/dist/features/column-visibility/columnVisibilityFeature.utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"columnVisibilityFeature.utils.cjs","names":["makeObjectMap","callMemoOrStaticFn","hasOwn","getDefaultColumnPinningState","cloneState"],"sources":["../../../src/features/column-visibility/columnVisibilityFeature.utils.ts"],"sourcesContent":["import {\n  callMemoOrStaticFn,\n  cloneState,\n  hasOwn,\n  makeObjectMap,\n} from '../../utils'\nimport { getDefaultColumnPinningState } from '../column-pinning/columnPinningFeature.utils'\nimport type { CellData, RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Cell } from '../../types/Cell'\nimport type { Column_Internal } from '../../types/Column'\nimport type { ColumnVisibilityState } from './columnVisibilityFeature.types'\nimport type { Row } from '../../types/Row'\n\n/**\n * Creates the default column visibility state.\n *\n * The feature default is an empty object, where missing column ids are treated\n * as visible. Reset APIs use this value when `defaultState` is `true`.\n *\n * @example\n * ```ts\n * const visibility = getDefaultColumnVisibilityState()\n * ```\n */\nexport function getDefaultColumnVisibilityState(): ColumnVisibilityState {\n  return makeObjectMap()\n}\n\n/**\n * Updates this column's visibility when hiding is allowed.\n *\n * Passing `visible` stores that value. Omitting it flips the column's current\n * visibility state. Columns that cannot hide are left unchanged.\n *\n * @example\n * ```ts\n * column_toggleVisibility(column)\n * ```\n */\nexport function column_toggleVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>, visible?: boolean): void {\n  if (column_getCanHide(column)) {\n    table_setColumnVisibility(column.table, (old) => {\n      const next = Object.assign(makeObjectMap<boolean>(), old)\n      next[column.id] =\n        visible ??\n        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)\n      return next\n    })\n  }\n}\n\n/**\n * Checks whether this column is visible.\n *\n * Leaf columns read `state.columnVisibility[column.id]`, where missing entries\n * default to visible. Parent columns are visible when at least one child column\n * is visible.\n *\n * @example\n * ```ts\n * const visible = column_getIsVisible(column)\n * ```\n */\nexport function column_getIsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): boolean {\n  const childColumns = column.columns\n  if (childColumns.length) {\n    return childColumns.some((childColumn) =>\n      callMemoOrStaticFn(childColumn, 'getIsVisible', column_getIsVisible),\n    )\n  }\n\n  const columnVisibility = column.table.atoms.columnVisibility?.get()\n  return (\n    (columnVisibility && hasOwn(columnVisibility, column.id)\n      ? columnVisibility[column.id]\n      : undefined) ?? true\n  )\n}\n\n/**\n * Checks whether this column is allowed to be hidden.\n *\n * Both `columnDef.enableHiding` and table `enableHiding` default to `true`.\n *\n * @example\n * ```ts\n * const canHide = column_getCanHide(column)\n * ```\n */\nexport function column_getCanHide<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (\n    (column.columnDef.enableHiding ?? true) &&\n    (column.table.options.enableHiding ?? true)\n  )\n}\n\n/**\n * Creates a checkbox-style handler that writes this column's visibility.\n *\n * The handler reads `event.target.checked`, so it is intended for visibility\n * controls whose checked state means \"visible\".\n *\n * @example\n * ```ts\n * const onChange = column_getToggleVisibilityHandler(column)\n * ```\n */\nexport function column_getToggleVisibilityHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (e: unknown) => {\n    column_toggleVisibility(\n      column,\n      ((e as MouseEvent).target as HTMLInputElement).checked,\n    )\n  }\n}\n\n/**\n * Collects the cells from this row whose columns are visible.\n *\n * When column pinning is active, the result is ordered as left-pinned cells,\n * center cells, then right-pinned cells.\n *\n * @example\n * ```ts\n * const visibleCells = row_getVisibleCells(row)\n * ```\n */\nexport function row_getVisibleCells<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>> {\n  const allCells = row.getAllCells()\n  const visibleCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < allCells.length; i++) {\n    const cell = allCells[i]!\n    if (callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible)) {\n      visibleCells.push(cell)\n    }\n  }\n\n  const { left, right } =\n    row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()\n  if (!left.length && !right.length) return visibleCells // no pinning, return early\n\n  const visibleCellsByColumnId = callMemoOrStaticFn(\n    row,\n    'getVisibleCellsByColumnId',\n    row_getVisibleCellsByColumnId,\n  )\n\n  const leftCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < left.length; i++) {\n    const cell = visibleCellsByColumnId[left[i]!]\n    if (cell) leftCells.push(cell)\n  }\n\n  const rightCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < right.length; i++) {\n    const cell = visibleCellsByColumnId[right[i]!]\n    if (cell) rightCells.push(cell)\n  }\n\n  // Center cells: visible cells in natural column order, minus pinned ones.\n  const centerCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < visibleCells.length; i++) {\n    const cell = visibleCells[i]!\n    const id = cell.column.id\n    if (!left.includes(id) && !right.includes(id)) centerCells.push(cell)\n  }\n\n  return [...leftCells, ...centerCells, ...rightCells]\n}\n\n/**\n * Builds a lookup map of this row's visible cells keyed by column id.\n *\n * Hidden columns are omitted from the map.\n *\n * @example\n * ```ts\n * const visibleCellsById = row_getVisibleCellsByColumnId(row)\n * ```\n */\nexport function row_getVisibleCellsByColumnId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Record<string, Cell<TFeatures, TData, unknown>> {\n  const result = makeObjectMap<Cell<TFeatures, TData, unknown>>()\n  const allCells = row.getAllCells()\n  for (let i = 0; i < allCells.length; i++) {\n    const cell = allCells[i]!\n    if (callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible)) {\n      result[cell.column.id] = cell\n    }\n  }\n  return result\n}\n\n/**\n * Filters the flat column list down to visible columns.\n *\n * Parent/group columns are included when `column_getIsVisible` considers them\n * visible.\n *\n * @example\n * ```ts\n * const columns = table_getVisibleFlatColumns(table)\n * ```\n */\nexport function table_getVisibleFlatColumns<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllFlatColumns()\n    .filter((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Filters leaf columns down to those currently visible.\n *\n * This is the column list most row rendering code uses before pinning-specific\n * partitioning.\n *\n * @example\n * ```ts\n * const columns = table_getVisibleLeafColumns(table)\n * ```\n */\nexport function table_getVisibleLeafColumns<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllLeafColumns()\n    .filter((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Routes a column visibility updater through the table's visibility change handler.\n *\n * The updater may be a next visibility map or a function of the previous map,\n * matching the instance `table.setColumnVisibility` behavior.\n *\n * @example\n * ```ts\n * table_setColumnVisibility(table, (old) => ({ ...old, age: false }))\n * ```\n */\nexport function table_setColumnVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<ColumnVisibilityState>,\n) {\n  table.options.onColumnVisibilityChange?.(updater)\n}\n\n/**\n * Resets `columnVisibility` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.columnVisibility` when\n * it exists. Passing `true` ignores initial state and resets to `{}`.\n *\n * @example\n * ```ts\n * table_resetColumnVisibility(table)\n * table_resetColumnVisibility(table, true)\n * ```\n */\nexport function table_resetColumnVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setColumnVisibility(\n    table,\n    defaultState\n      ? makeObjectMap()\n      : Object.assign(\n          makeObjectMap<boolean>(),\n          cloneState(table.initialState.columnVisibility ?? {}),\n        ),\n  )\n}\n\n/**\n * Shows or hides every hideable leaf column.\n *\n * Columns that cannot hide stay visible when toggling all columns off.\n *\n * @example\n * ```ts\n * table_toggleAllColumnsVisible(table)\n * ```\n */\nexport function table_toggleAllColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, value?: boolean) {\n  value = value ?? !table_getIsAllColumnsVisible(table)\n\n  const visibility = makeObjectMap<boolean>()\n  const leafColumns = table.getAllLeafColumns()\n  for (let i = 0; i < leafColumns.length; i++) {\n    const column = leafColumns[i]!\n    visibility[column.id] = !value ? !column_getCanHide(column) : value\n  }\n\n  table_setColumnVisibility(table, visibility)\n}\n\n/**\n * Checks whether every leaf column is currently visible.\n *\n * Non-hideable columns are naturally visible because missing visibility entries\n * default to `true`.\n *\n * @example\n * ```ts\n * const allVisible = table_getIsAllColumnsVisible(table)\n * ```\n */\nexport function table_getIsAllColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return !table\n    .getAllLeafColumns()\n    .some(\n      (column) =>\n        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Checks whether at least one leaf column is currently visible.\n *\n * This is useful for tri-state \"show all columns\" controls.\n *\n * @example\n * ```ts\n * const someVisible = table_getIsSomeColumnsVisible(table)\n * ```\n */\nexport function table_getIsSomeColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllLeafColumns()\n    .some((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Creates a checkbox-style handler that shows or hides all columns.\n *\n * The handler reads `event.target.checked`, so it is intended for controls whose\n * checked state means \"all columns visible\".\n *\n * @example\n * ```ts\n * const onChange = table_getToggleAllColumnsVisibilityHandler(table)\n * ```\n */\nexport function table_getToggleAllColumnsVisibilityHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (e: unknown) => {\n    table_toggleAllColumnsVisible(\n      table,\n      ((e as MouseEvent).target as HTMLInputElement).checked,\n    )\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"columnVisibilityFeature.utils.cjs","names":["makeObjectMap","callMemoOrStaticFn","hasOwn","getDefaultColumnPinningState","cloneState"],"sources":["../../../src/features/column-visibility/columnVisibilityFeature.utils.ts"],"sourcesContent":["import {\n  callMemoOrStaticFn,\n  cloneState,\n  hasOwn,\n  makeObjectMap,\n} from '../../utils'\nimport { getDefaultColumnPinningState } from '../column-pinning/columnPinningFeature.utils'\nimport type { CellData, RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Cell } from '../../types/Cell'\nimport type { Column_Internal } from '../../types/Column'\nimport type { ColumnVisibilityState } from './columnVisibilityFeature.types'\nimport type { Row } from '../../types/Row'\n\n/**\n * Creates the default column visibility state.\n *\n * The feature default is an empty object, where missing column ids are treated\n * as visible. Reset APIs use this value when `defaultState` is `true`.\n *\n * @example\n * ```ts\n * const visibility = getDefaultColumnVisibilityState()\n * ```\n */\nexport function getDefaultColumnVisibilityState(): ColumnVisibilityState {\n  return makeObjectMap()\n}\n\n/**\n * Updates this column's visibility when hiding is allowed.\n *\n * Passing `visible` stores that value. Omitting it flips the column's current\n * visibility state. Columns that cannot hide are left unchanged.\n *\n * @example\n * ```ts\n * column_toggleVisibility(column)\n * ```\n */\nexport function column_toggleVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>, visible?: boolean): void {\n  if (column_getCanHide(column)) {\n    table_setColumnVisibility(column.table, (old) => {\n      const next = Object.assign(makeObjectMap<boolean>(), old)\n      next[column.id] =\n        visible ??\n        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)\n      return next\n    })\n  }\n}\n\n/**\n * Checks whether this column is visible.\n *\n * Leaf columns read `state.columnVisibility[column.id]`, where missing entries\n * default to visible. Parent columns are visible when at least one child column\n * is visible.\n *\n * @example\n * ```ts\n * const visible = column_getIsVisible(column)\n * ```\n */\nexport function column_getIsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): boolean {\n  const columnVisibility = column.table.atoms.columnVisibility?.get()\n  if (!columnVisibility) return true\n\n  const childColumns = column.columns\n  if (childColumns.length) {\n    return childColumns.some((childColumn) =>\n      callMemoOrStaticFn(childColumn, 'getIsVisible', column_getIsVisible),\n    )\n  }\n\n  return (\n    (hasOwn(columnVisibility, column.id)\n      ? columnVisibility[column.id]\n      : undefined) ?? true\n  )\n}\n\n/**\n * Checks whether this column is allowed to be hidden.\n *\n * Both `columnDef.enableHiding` and table `enableHiding` default to `true`.\n *\n * @example\n * ```ts\n * const canHide = column_getCanHide(column)\n * ```\n */\nexport function column_getCanHide<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (\n    (column.columnDef.enableHiding ?? true) &&\n    (column.table.options.enableHiding ?? true)\n  )\n}\n\n/**\n * Creates a checkbox-style handler that writes this column's visibility.\n *\n * The handler reads `event.target.checked`, so it is intended for visibility\n * controls whose checked state means \"visible\".\n *\n * @example\n * ```ts\n * const onChange = column_getToggleVisibilityHandler(column)\n * ```\n */\nexport function column_getToggleVisibilityHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (e: unknown) => {\n    column_toggleVisibility(\n      column,\n      ((e as MouseEvent).target as HTMLInputElement).checked,\n    )\n  }\n}\n\n/**\n * Collects the cells from this row whose columns are visible.\n *\n * When column pinning is active, the result is ordered as left-pinned cells,\n * center cells, then right-pinned cells.\n *\n * @example\n * ```ts\n * const visibleCells = row_getVisibleCells(row)\n * ```\n */\nexport function row_getVisibleCells<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>> {\n  const allCells = row.getAllCells()\n  const visibleCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < allCells.length; i++) {\n    const cell = allCells[i]!\n    if (callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible)) {\n      visibleCells.push(cell)\n    }\n  }\n\n  const { left, right } =\n    row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()\n  if (!left.length && !right.length) return visibleCells // no pinning, return early\n\n  const visibleCellsByColumnId = callMemoOrStaticFn(\n    row,\n    'getVisibleCellsByColumnId',\n    row_getVisibleCellsByColumnId,\n  )\n\n  const leftCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < left.length; i++) {\n    const cell = visibleCellsByColumnId[left[i]!]\n    if (cell) leftCells.push(cell)\n  }\n\n  const rightCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < right.length; i++) {\n    const cell = visibleCellsByColumnId[right[i]!]\n    if (cell) rightCells.push(cell)\n  }\n\n  // Center cells: visible cells in natural column order, minus pinned ones.\n  const centerCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < visibleCells.length; i++) {\n    const cell = visibleCells[i]!\n    const id = cell.column.id\n    if (!left.includes(id) && !right.includes(id)) centerCells.push(cell)\n  }\n\n  return [...leftCells, ...centerCells, ...rightCells]\n}\n\n/**\n * Builds a lookup map of this row's visible cells keyed by column id.\n *\n * Hidden columns are omitted from the map.\n *\n * @example\n * ```ts\n * const visibleCellsById = row_getVisibleCellsByColumnId(row)\n * ```\n */\nexport function row_getVisibleCellsByColumnId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Record<string, Cell<TFeatures, TData, unknown>> {\n  const result = makeObjectMap<Cell<TFeatures, TData, unknown>>()\n  const allCells = row.getAllCells()\n  for (let i = 0; i < allCells.length; i++) {\n    const cell = allCells[i]!\n    if (callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible)) {\n      result[cell.column.id] = cell\n    }\n  }\n  return result\n}\n\n/**\n * Filters the flat column list down to visible columns.\n *\n * Parent/group columns are included when `column_getIsVisible` considers them\n * visible.\n *\n * @example\n * ```ts\n * const columns = table_getVisibleFlatColumns(table)\n * ```\n */\nexport function table_getVisibleFlatColumns<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllFlatColumns()\n    .filter((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Filters leaf columns down to those currently visible.\n *\n * This is the column list most row rendering code uses before pinning-specific\n * partitioning.\n *\n * @example\n * ```ts\n * const columns = table_getVisibleLeafColumns(table)\n * ```\n */\nexport function table_getVisibleLeafColumns<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllLeafColumns()\n    .filter((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Routes a column visibility updater through the table's visibility change handler.\n *\n * The updater may be a next visibility map or a function of the previous map,\n * matching the instance `table.setColumnVisibility` behavior.\n *\n * @example\n * ```ts\n * table_setColumnVisibility(table, (old) => ({ ...old, age: false }))\n * ```\n */\nexport function table_setColumnVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<ColumnVisibilityState>,\n) {\n  table.options.onColumnVisibilityChange?.(updater)\n}\n\n/**\n * Resets `columnVisibility` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.columnVisibility` when\n * it exists. Passing `true` ignores initial state and resets to `{}`.\n *\n * @example\n * ```ts\n * table_resetColumnVisibility(table)\n * table_resetColumnVisibility(table, true)\n * ```\n */\nexport function table_resetColumnVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setColumnVisibility(\n    table,\n    defaultState\n      ? makeObjectMap()\n      : Object.assign(\n          makeObjectMap<boolean>(),\n          cloneState(table.initialState.columnVisibility ?? {}),\n        ),\n  )\n}\n\n/**\n * Shows or hides every hideable leaf column.\n *\n * Columns that cannot hide stay visible when toggling all columns off.\n *\n * @example\n * ```ts\n * table_toggleAllColumnsVisible(table)\n * ```\n */\nexport function table_toggleAllColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, value?: boolean) {\n  value = value ?? !table_getIsAllColumnsVisible(table)\n\n  const visibility = makeObjectMap<boolean>()\n  const leafColumns = table.getAllLeafColumns()\n  for (let i = 0; i < leafColumns.length; i++) {\n    const column = leafColumns[i]!\n    visibility[column.id] = !value ? !column_getCanHide(column) : value\n  }\n\n  table_setColumnVisibility(table, visibility)\n}\n\n/**\n * Checks whether every leaf column is currently visible.\n *\n * Non-hideable columns are naturally visible because missing visibility entries\n * default to `true`.\n *\n * @example\n * ```ts\n * const allVisible = table_getIsAllColumnsVisible(table)\n * ```\n */\nexport function table_getIsAllColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return !table\n    .getAllLeafColumns()\n    .some(\n      (column) =>\n        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Checks whether at least one leaf column is currently visible.\n *\n * This is useful for tri-state \"show all columns\" controls.\n *\n * @example\n * ```ts\n * const someVisible = table_getIsSomeColumnsVisible(table)\n * ```\n */\nexport function table_getIsSomeColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllLeafColumns()\n    .some((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Creates a checkbox-style handler that shows or hides all columns.\n *\n * The handler reads `event.target.checked`, so it is intended for controls whose\n * checked state means \"all columns visible\".\n *\n * @example\n * ```ts\n * const onChange = table_getToggleAllColumnsVisibilityHandler(table)\n * ```\n */\nexport function table_getToggleAllColumnsVisibilityHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (e: unknown) => {\n    table_toggleAllColumnsVisible(\n      table,\n      ((e as MouseEvent).target as HTMLInputElement).checked,\n    )\n  }\n}\n"],"mappings":"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"}

package/dist/features/column-visibility/columnVisibilityFeature.utils.js

@@ -48,10 +48,11 @@ function column_toggleVisibility(column, visible) {
 */
 function column_getIsVisible(column) {
 	var _column$table$atoms$c;
+	const columnVisibility = (_column$table$atoms$c = column.table.atoms.columnVisibility) === null || _column$table$atoms$c === void 0 ? void 0 : _column$table$atoms$c.get();
+	if (!columnVisibility) return true;
 	const childColumns = column.columns;
 	if (childColumns.length) return childColumns.some((childColumn) => callMemoOrStaticFn(childColumn, "getIsVisible", column_getIsVisible));
-	const columnVisibility = (_column$table$atoms$c = column.table.atoms.columnVisibility) === null || _column$table$atoms$c === void 0 ? void 0 : _column$table$atoms$c.get();
-	return (columnVisibility && hasOwn(columnVisibility, column.id) ? columnVisibility[column.id] : void 0) ?? true;
+	return (hasOwn(columnVisibility, column.id) ? columnVisibility[column.id] : void 0) ?? true;
 }
 /**
 * Checks whether this column is allowed to be hidden.

package/dist/features/column-visibility/columnVisibilityFeature.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"columnVisibilityFeature.utils.js","names":[],"sources":["../../../src/features/column-visibility/columnVisibilityFeature.utils.ts"],"sourcesContent":["import {\n  callMemoOrStaticFn,\n  cloneState,\n  hasOwn,\n  makeObjectMap,\n} from '../../utils'\nimport { getDefaultColumnPinningState } from '../column-pinning/columnPinningFeature.utils'\nimport type { CellData, RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Cell } from '../../types/Cell'\nimport type { Column_Internal } from '../../types/Column'\nimport type { ColumnVisibilityState } from './columnVisibilityFeature.types'\nimport type { Row } from '../../types/Row'\n\n/**\n * Creates the default column visibility state.\n *\n * The feature default is an empty object, where missing column ids are treated\n * as visible. Reset APIs use this value when `defaultState` is `true`.\n *\n * @example\n * ```ts\n * const visibility = getDefaultColumnVisibilityState()\n * ```\n */\nexport function getDefaultColumnVisibilityState(): ColumnVisibilityState {\n  return makeObjectMap()\n}\n\n/**\n * Updates this column's visibility when hiding is allowed.\n *\n * Passing `visible` stores that value. Omitting it flips the column's current\n * visibility state. Columns that cannot hide are left unchanged.\n *\n * @example\n * ```ts\n * column_toggleVisibility(column)\n * ```\n */\nexport function column_toggleVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>, visible?: boolean): void {\n  if (column_getCanHide(column)) {\n    table_setColumnVisibility(column.table, (old) => {\n      const next = Object.assign(makeObjectMap<boolean>(), old)\n      next[column.id] =\n        visible ??\n        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)\n      return next\n    })\n  }\n}\n\n/**\n * Checks whether this column is visible.\n *\n * Leaf columns read `state.columnVisibility[column.id]`, where missing entries\n * default to visible. Parent columns are visible when at least one child column\n * is visible.\n *\n * @example\n * ```ts\n * const visible = column_getIsVisible(column)\n * ```\n */\nexport function column_getIsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): boolean {\n  const childColumns = column.columns\n  if (childColumns.length) {\n    return childColumns.some((childColumn) =>\n      callMemoOrStaticFn(childColumn, 'getIsVisible', column_getIsVisible),\n    )\n  }\n\n  const columnVisibility = column.table.atoms.columnVisibility?.get()\n  return (\n    (columnVisibility && hasOwn(columnVisibility, column.id)\n      ? columnVisibility[column.id]\n      : undefined) ?? true\n  )\n}\n\n/**\n * Checks whether this column is allowed to be hidden.\n *\n * Both `columnDef.enableHiding` and table `enableHiding` default to `true`.\n *\n * @example\n * ```ts\n * const canHide = column_getCanHide(column)\n * ```\n */\nexport function column_getCanHide<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (\n    (column.columnDef.enableHiding ?? true) &&\n    (column.table.options.enableHiding ?? true)\n  )\n}\n\n/**\n * Creates a checkbox-style handler that writes this column's visibility.\n *\n * The handler reads `event.target.checked`, so it is intended for visibility\n * controls whose checked state means \"visible\".\n *\n * @example\n * ```ts\n * const onChange = column_getToggleVisibilityHandler(column)\n * ```\n */\nexport function column_getToggleVisibilityHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (e: unknown) => {\n    column_toggleVisibility(\n      column,\n      ((e as MouseEvent).target as HTMLInputElement).checked,\n    )\n  }\n}\n\n/**\n * Collects the cells from this row whose columns are visible.\n *\n * When column pinning is active, the result is ordered as left-pinned cells,\n * center cells, then right-pinned cells.\n *\n * @example\n * ```ts\n * const visibleCells = row_getVisibleCells(row)\n * ```\n */\nexport function row_getVisibleCells<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>> {\n  const allCells = row.getAllCells()\n  const visibleCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < allCells.length; i++) {\n    const cell = allCells[i]!\n    if (callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible)) {\n      visibleCells.push(cell)\n    }\n  }\n\n  const { left, right } =\n    row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()\n  if (!left.length && !right.length) return visibleCells // no pinning, return early\n\n  const visibleCellsByColumnId = callMemoOrStaticFn(\n    row,\n    'getVisibleCellsByColumnId',\n    row_getVisibleCellsByColumnId,\n  )\n\n  const leftCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < left.length; i++) {\n    const cell = visibleCellsByColumnId[left[i]!]\n    if (cell) leftCells.push(cell)\n  }\n\n  const rightCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < right.length; i++) {\n    const cell = visibleCellsByColumnId[right[i]!]\n    if (cell) rightCells.push(cell)\n  }\n\n  // Center cells: visible cells in natural column order, minus pinned ones.\n  const centerCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < visibleCells.length; i++) {\n    const cell = visibleCells[i]!\n    const id = cell.column.id\n    if (!left.includes(id) && !right.includes(id)) centerCells.push(cell)\n  }\n\n  return [...leftCells, ...centerCells, ...rightCells]\n}\n\n/**\n * Builds a lookup map of this row's visible cells keyed by column id.\n *\n * Hidden columns are omitted from the map.\n *\n * @example\n * ```ts\n * const visibleCellsById = row_getVisibleCellsByColumnId(row)\n * ```\n */\nexport function row_getVisibleCellsByColumnId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Record<string, Cell<TFeatures, TData, unknown>> {\n  const result = makeObjectMap<Cell<TFeatures, TData, unknown>>()\n  const allCells = row.getAllCells()\n  for (let i = 0; i < allCells.length; i++) {\n    const cell = allCells[i]!\n    if (callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible)) {\n      result[cell.column.id] = cell\n    }\n  }\n  return result\n}\n\n/**\n * Filters the flat column list down to visible columns.\n *\n * Parent/group columns are included when `column_getIsVisible` considers them\n * visible.\n *\n * @example\n * ```ts\n * const columns = table_getVisibleFlatColumns(table)\n * ```\n */\nexport function table_getVisibleFlatColumns<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllFlatColumns()\n    .filter((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Filters leaf columns down to those currently visible.\n *\n * This is the column list most row rendering code uses before pinning-specific\n * partitioning.\n *\n * @example\n * ```ts\n * const columns = table_getVisibleLeafColumns(table)\n * ```\n */\nexport function table_getVisibleLeafColumns<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllLeafColumns()\n    .filter((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Routes a column visibility updater through the table's visibility change handler.\n *\n * The updater may be a next visibility map or a function of the previous map,\n * matching the instance `table.setColumnVisibility` behavior.\n *\n * @example\n * ```ts\n * table_setColumnVisibility(table, (old) => ({ ...old, age: false }))\n * ```\n */\nexport function table_setColumnVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<ColumnVisibilityState>,\n) {\n  table.options.onColumnVisibilityChange?.(updater)\n}\n\n/**\n * Resets `columnVisibility` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.columnVisibility` when\n * it exists. Passing `true` ignores initial state and resets to `{}`.\n *\n * @example\n * ```ts\n * table_resetColumnVisibility(table)\n * table_resetColumnVisibility(table, true)\n * ```\n */\nexport function table_resetColumnVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setColumnVisibility(\n    table,\n    defaultState\n      ? makeObjectMap()\n      : Object.assign(\n          makeObjectMap<boolean>(),\n          cloneState(table.initialState.columnVisibility ?? {}),\n        ),\n  )\n}\n\n/**\n * Shows or hides every hideable leaf column.\n *\n * Columns that cannot hide stay visible when toggling all columns off.\n *\n * @example\n * ```ts\n * table_toggleAllColumnsVisible(table)\n * ```\n */\nexport function table_toggleAllColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, value?: boolean) {\n  value = value ?? !table_getIsAllColumnsVisible(table)\n\n  const visibility = makeObjectMap<boolean>()\n  const leafColumns = table.getAllLeafColumns()\n  for (let i = 0; i < leafColumns.length; i++) {\n    const column = leafColumns[i]!\n    visibility[column.id] = !value ? !column_getCanHide(column) : value\n  }\n\n  table_setColumnVisibility(table, visibility)\n}\n\n/**\n * Checks whether every leaf column is currently visible.\n *\n * Non-hideable columns are naturally visible because missing visibility entries\n * default to `true`.\n *\n * @example\n * ```ts\n * const allVisible = table_getIsAllColumnsVisible(table)\n * ```\n */\nexport function table_getIsAllColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return !table\n    .getAllLeafColumns()\n    .some(\n      (column) =>\n        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Checks whether at least one leaf column is currently visible.\n *\n * This is useful for tri-state \"show all columns\" controls.\n *\n * @example\n * ```ts\n * const someVisible = table_getIsSomeColumnsVisible(table)\n * ```\n */\nexport function table_getIsSomeColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllLeafColumns()\n    .some((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Creates a checkbox-style handler that shows or hides all columns.\n *\n * The handler reads `event.target.checked`, so it is intended for controls whose\n * checked state means \"all columns visible\".\n *\n * @example\n * ```ts\n * const onChange = table_getToggleAllColumnsVisibilityHandler(table)\n * ```\n */\nexport function table_getToggleAllColumnsVisibilityHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (e: unknown) => {\n    table_toggleAllColumnsVisible(\n      table,\n      ((e as MouseEvent).target as HTMLInputElement).checked,\n    )\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"columnVisibilityFeature.utils.js","names":[],"sources":["../../../src/features/column-visibility/columnVisibilityFeature.utils.ts"],"sourcesContent":["import {\n  callMemoOrStaticFn,\n  cloneState,\n  hasOwn,\n  makeObjectMap,\n} from '../../utils'\nimport { getDefaultColumnPinningState } from '../column-pinning/columnPinningFeature.utils'\nimport type { CellData, RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Cell } from '../../types/Cell'\nimport type { Column_Internal } from '../../types/Column'\nimport type { ColumnVisibilityState } from './columnVisibilityFeature.types'\nimport type { Row } from '../../types/Row'\n\n/**\n * Creates the default column visibility state.\n *\n * The feature default is an empty object, where missing column ids are treated\n * as visible. Reset APIs use this value when `defaultState` is `true`.\n *\n * @example\n * ```ts\n * const visibility = getDefaultColumnVisibilityState()\n * ```\n */\nexport function getDefaultColumnVisibilityState(): ColumnVisibilityState {\n  return makeObjectMap()\n}\n\n/**\n * Updates this column's visibility when hiding is allowed.\n *\n * Passing `visible` stores that value. Omitting it flips the column's current\n * visibility state. Columns that cannot hide are left unchanged.\n *\n * @example\n * ```ts\n * column_toggleVisibility(column)\n * ```\n */\nexport function column_toggleVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>, visible?: boolean): void {\n  if (column_getCanHide(column)) {\n    table_setColumnVisibility(column.table, (old) => {\n      const next = Object.assign(makeObjectMap<boolean>(), old)\n      next[column.id] =\n        visible ??\n        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)\n      return next\n    })\n  }\n}\n\n/**\n * Checks whether this column is visible.\n *\n * Leaf columns read `state.columnVisibility[column.id]`, where missing entries\n * default to visible. Parent columns are visible when at least one child column\n * is visible.\n *\n * @example\n * ```ts\n * const visible = column_getIsVisible(column)\n * ```\n */\nexport function column_getIsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): boolean {\n  const columnVisibility = column.table.atoms.columnVisibility?.get()\n  if (!columnVisibility) return true\n\n  const childColumns = column.columns\n  if (childColumns.length) {\n    return childColumns.some((childColumn) =>\n      callMemoOrStaticFn(childColumn, 'getIsVisible', column_getIsVisible),\n    )\n  }\n\n  return (\n    (hasOwn(columnVisibility, column.id)\n      ? columnVisibility[column.id]\n      : undefined) ?? true\n  )\n}\n\n/**\n * Checks whether this column is allowed to be hidden.\n *\n * Both `columnDef.enableHiding` and table `enableHiding` default to `true`.\n *\n * @example\n * ```ts\n * const canHide = column_getCanHide(column)\n * ```\n */\nexport function column_getCanHide<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (\n    (column.columnDef.enableHiding ?? true) &&\n    (column.table.options.enableHiding ?? true)\n  )\n}\n\n/**\n * Creates a checkbox-style handler that writes this column's visibility.\n *\n * The handler reads `event.target.checked`, so it is intended for visibility\n * controls whose checked state means \"visible\".\n *\n * @example\n * ```ts\n * const onChange = column_getToggleVisibilityHandler(column)\n * ```\n */\nexport function column_getToggleVisibilityHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (e: unknown) => {\n    column_toggleVisibility(\n      column,\n      ((e as MouseEvent).target as HTMLInputElement).checked,\n    )\n  }\n}\n\n/**\n * Collects the cells from this row whose columns are visible.\n *\n * When column pinning is active, the result is ordered as left-pinned cells,\n * center cells, then right-pinned cells.\n *\n * @example\n * ```ts\n * const visibleCells = row_getVisibleCells(row)\n * ```\n */\nexport function row_getVisibleCells<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>> {\n  const allCells = row.getAllCells()\n  const visibleCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < allCells.length; i++) {\n    const cell = allCells[i]!\n    if (callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible)) {\n      visibleCells.push(cell)\n    }\n  }\n\n  const { left, right } =\n    row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()\n  if (!left.length && !right.length) return visibleCells // no pinning, return early\n\n  const visibleCellsByColumnId = callMemoOrStaticFn(\n    row,\n    'getVisibleCellsByColumnId',\n    row_getVisibleCellsByColumnId,\n  )\n\n  const leftCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < left.length; i++) {\n    const cell = visibleCellsByColumnId[left[i]!]\n    if (cell) leftCells.push(cell)\n  }\n\n  const rightCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < right.length; i++) {\n    const cell = visibleCellsByColumnId[right[i]!]\n    if (cell) rightCells.push(cell)\n  }\n\n  // Center cells: visible cells in natural column order, minus pinned ones.\n  const centerCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < visibleCells.length; i++) {\n    const cell = visibleCells[i]!\n    const id = cell.column.id\n    if (!left.includes(id) && !right.includes(id)) centerCells.push(cell)\n  }\n\n  return [...leftCells, ...centerCells, ...rightCells]\n}\n\n/**\n * Builds a lookup map of this row's visible cells keyed by column id.\n *\n * Hidden columns are omitted from the map.\n *\n * @example\n * ```ts\n * const visibleCellsById = row_getVisibleCellsByColumnId(row)\n * ```\n */\nexport function row_getVisibleCellsByColumnId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Record<string, Cell<TFeatures, TData, unknown>> {\n  const result = makeObjectMap<Cell<TFeatures, TData, unknown>>()\n  const allCells = row.getAllCells()\n  for (let i = 0; i < allCells.length; i++) {\n    const cell = allCells[i]!\n    if (callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible)) {\n      result[cell.column.id] = cell\n    }\n  }\n  return result\n}\n\n/**\n * Filters the flat column list down to visible columns.\n *\n * Parent/group columns are included when `column_getIsVisible` considers them\n * visible.\n *\n * @example\n * ```ts\n * const columns = table_getVisibleFlatColumns(table)\n * ```\n */\nexport function table_getVisibleFlatColumns<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllFlatColumns()\n    .filter((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Filters leaf columns down to those currently visible.\n *\n * This is the column list most row rendering code uses before pinning-specific\n * partitioning.\n *\n * @example\n * ```ts\n * const columns = table_getVisibleLeafColumns(table)\n * ```\n */\nexport function table_getVisibleLeafColumns<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllLeafColumns()\n    .filter((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Routes a column visibility updater through the table's visibility change handler.\n *\n * The updater may be a next visibility map or a function of the previous map,\n * matching the instance `table.setColumnVisibility` behavior.\n *\n * @example\n * ```ts\n * table_setColumnVisibility(table, (old) => ({ ...old, age: false }))\n * ```\n */\nexport function table_setColumnVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<ColumnVisibilityState>,\n) {\n  table.options.onColumnVisibilityChange?.(updater)\n}\n\n/**\n * Resets `columnVisibility` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.columnVisibility` when\n * it exists. Passing `true` ignores initial state and resets to `{}`.\n *\n * @example\n * ```ts\n * table_resetColumnVisibility(table)\n * table_resetColumnVisibility(table, true)\n * ```\n */\nexport function table_resetColumnVisibility<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setColumnVisibility(\n    table,\n    defaultState\n      ? makeObjectMap()\n      : Object.assign(\n          makeObjectMap<boolean>(),\n          cloneState(table.initialState.columnVisibility ?? {}),\n        ),\n  )\n}\n\n/**\n * Shows or hides every hideable leaf column.\n *\n * Columns that cannot hide stay visible when toggling all columns off.\n *\n * @example\n * ```ts\n * table_toggleAllColumnsVisible(table)\n * ```\n */\nexport function table_toggleAllColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, value?: boolean) {\n  value = value ?? !table_getIsAllColumnsVisible(table)\n\n  const visibility = makeObjectMap<boolean>()\n  const leafColumns = table.getAllLeafColumns()\n  for (let i = 0; i < leafColumns.length; i++) {\n    const column = leafColumns[i]!\n    visibility[column.id] = !value ? !column_getCanHide(column) : value\n  }\n\n  table_setColumnVisibility(table, visibility)\n}\n\n/**\n * Checks whether every leaf column is currently visible.\n *\n * Non-hideable columns are naturally visible because missing visibility entries\n * default to `true`.\n *\n * @example\n * ```ts\n * const allVisible = table_getIsAllColumnsVisible(table)\n * ```\n */\nexport function table_getIsAllColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return !table\n    .getAllLeafColumns()\n    .some(\n      (column) =>\n        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Checks whether at least one leaf column is currently visible.\n *\n * This is useful for tri-state \"show all columns\" controls.\n *\n * @example\n * ```ts\n * const someVisible = table_getIsSomeColumnsVisible(table)\n * ```\n */\nexport function table_getIsSomeColumnsVisible<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getAllLeafColumns()\n    .some((column) =>\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    )\n}\n\n/**\n * Creates a checkbox-style handler that shows or hides all columns.\n *\n * The handler reads `event.target.checked`, so it is intended for controls whose\n * checked state means \"all columns visible\".\n *\n * @example\n * ```ts\n * const onChange = table_getToggleAllColumnsVisibilityHandler(table)\n * ```\n */\nexport function table_getToggleAllColumnsVisibilityHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (e: unknown) => {\n    table_toggleAllColumnsVisible(\n      table,\n      ((e as MouseEvent).target as HTMLInputElement).checked,\n    )\n  }\n}\n"],"mappings":"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"}

package/dist/features/row-selection/rowSelectionFeature.utils.cjs

@@ -240,7 +240,7 @@ function table_getIsSomeRowsSelected(table) {
 * ```
 */
 function table_getIsSomePageRowsSelected(table) {
-	return table.getPaginatedRowModel().flatRows.filter((row) => row_getCanSelect(row)).some((row) => row_getIsSelected(row) || row_getIsSomeSelected(row));
+	return table.getPaginatedRowModel().flatRows.filter((row) => row_getCanSelect(row)).some((row) => row_getIsSelected(row) || require_utils.callMemoOrStaticFn(row, "getIsSomeSelected", row_getIsSomeSelected));
 }
 /**
 * Creates a checkbox-style handler that selects or deselects all rows.