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

package/dist/features/column-visibility/columnVisibilityFeature.types.d.ts

@@ -23,31 +23,34 @@ interface TableOptions_ColumnVisibility {
 type VisibilityDefaultOptions = Pick<TableOptions_ColumnVisibility, 'onColumnVisibilityChange'>;
 interface Table_ColumnVisibility<TFeatures extends TableFeatures, TData extends RowData> {
   /**
-   * Returns whether all columns are visible
+   * Checks whether every leaf column is currently visible.
    */
   getIsAllColumnsVisible: () => boolean;
   /**
-   * Returns whether any columns are visible
+   * Checks whether at least one leaf column is currently visible.
    */
   getIsSomeColumnsVisible: () => boolean;
   /**
-   * Returns a handler for toggling the visibility of all columns, meant to be bound to a `input[type=checkbox]` element.
+   * Creates a checkbox-style handler that shows or hides all columns.
    */
   getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
   /**
-   * Returns a flat array of columns that are visible, including parent columns.
+   * Lists visible columns in flat table order, including parent columns that
+   * have visible descendants.
    */
   getVisibleFlatColumns: () => Array<Column<TFeatures, TData, unknown>>;
   /**
-   * Returns a flat array of leaf-node columns that are visible.
+   * Lists visible leaf columns in the order used for row cells and headers.
    */
   getVisibleLeafColumns: () => Array<Column<TFeatures, TData, unknown>>;
   /**
-   * Resets the column visibility state to the initial state. If `defaultState` is provided, the state will be reset to `{}`
+   * Resets `columnVisibility` to `initialState.columnVisibility`.
+   *
+   * Pass `true` to ignore initial state and reset to `{}`.
    */
   resetColumnVisibility: (defaultState?: boolean) => void;
   /**
-   * Sets column visibility state using a value or updater.
+   * Updates column visibility state with a next map or updater function.
    */
   setColumnVisibility: (updater: Updater<ColumnVisibilityState>) => void;
   /**
@@ -57,31 +60,31 @@ interface Table_ColumnVisibility<TFeatures extends TableFeatures, TData extends
 }
 interface ColumnDef_ColumnVisibility {
   /**
-   * Enables/disables column hiding for this column. Defaults to `true`.
+   * Allows this column to be hidden. Defaults to `true`.
    */
   enableHiding?: boolean;
 }
 interface Row_ColumnVisibility<TFeatures extends TableFeatures, TData extends RowData> {
   /**
-   * Returns an array of cells that account for column visibility for the row.
+   * Gets this row's cells for currently visible columns.
    */
   getVisibleCells: () => Array<Cell<TFeatures, TData, unknown>>;
   /**
-   * Returns visible cells by column id for the row.
+   * Maps this row's currently visible cells by column id.
    */
   getVisibleCellsByColumnId: () => Record<string, Cell<TFeatures, TData, unknown>>;
 }
 interface Column_ColumnVisibility {
   /**
-   * Returns whether the column can be hidden
+   * Checks whether this column is allowed to be hidden.
    */
   getCanHide: () => boolean;
   /**
-   * Returns whether the column is visible
+   * Checks whether this column is currently visible.
    */
   getIsVisible: () => boolean;
   /**
-   * Returns a function that can be used to toggle the column visibility. This function can be used to bind to an event handler to a checkbox.
+   * Creates a checkbox-style handler that toggles this column's visibility.
    */
   getToggleVisibilityHandler: () => (event: unknown) => void;
   /**

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

@@ -3,22 +3,24 @@ const require_columnPinningFeature_utils = require('../column-pinning/columnPinn
 
 //#region src/features/column-visibility/columnVisibilityFeature.utils.ts
 /**
-* Returns the default column visibility state.
+* Creates the default column visibility state.
 *
-* Feature constructors use this value to initialize the table state or option defaults when no user value is provided.
+* The feature default is an empty object, where missing column ids are treated
+* as visible. Reset APIs use this value when `defaultState` is `true`.
 *
 * @example
 * ```ts
-* const initialValue = getDefaultColumnVisibilityState()
+* const visibility = getDefaultColumnVisibilityState()
 * ```
 */
 function getDefaultColumnVisibilityState() {
 	return {};
 }
 /**
-* Toggles visibility for a column.
+* Updates this column's visibility when hiding is allowed.
 *
-* The update is applied through the owning table state slice and respects the feature options for that column.
+* Passing `visible` stores that value. Omitting it flips the column's current
+* visibility state. Columns that cannot hide are left unchanged.
 *
 * @example
 * ```ts
@@ -32,13 +34,15 @@ function column_toggleVisibility(column, visible) {
 	}));
 }
 /**
-* Returns is visible for a column.
+* Checks whether this column is visible.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* Leaf columns read `state.columnVisibility[column.id]`, where missing entries
+* default to visible. Parent columns are visible when at least one child column
+* is visible.
 *
 * @example
 * ```ts
-* const value = column_getIsVisible(column)
+* const visible = column_getIsVisible(column)
 * ```
 */
 function column_getIsVisible(column) {
@@ -47,26 +51,27 @@ function column_getIsVisible(column) {
 	return (childColumns.length ? childColumns.some((childColumn) => require_utils.callMemoOrStaticFn(childColumn, "getIsVisible", column_getIsVisible)) : (_column$table$atoms$c = column.table.atoms.columnVisibility) === null || _column$table$atoms$c === void 0 || (_column$table$atoms$c = _column$table$atoms$c.get()) === null || _column$table$atoms$c === void 0 ? void 0 : _column$table$atoms$c[column.id]) ?? true;
 }
 /**
-* Returns whether a column can use hide.
+* Checks whether this column is allowed to be hidden.
 *
-* This combines column options, table options, and any required accessor or feature state for the capability.
+* Both `columnDef.enableHiding` and table `enableHiding` default to `true`.
 *
 * @example
 * ```ts
-* const value = column_getCanHide(column)
+* const canHide = column_getCanHide(column)
 * ```
 */
 function column_getCanHide(column) {
 	return (column.columnDef.enableHiding ?? true) && (column.table.options.enableHiding ?? true);
 }
 /**
-* Returns an event handler for toggling visibility handler.
+* Creates a checkbox-style handler that writes this column's visibility.
 *
-* The handler is intended for direct use in column header controls such as buttons or checkboxes.
+* The handler reads `event.target.checked`, so it is intended for visibility
+* controls whose checked state means "visible".
 *
 * @example
 * ```ts
-* const value = column_getToggleVisibilityHandler(column)
+* const onChange = column_getToggleVisibilityHandler(column)
 * ```
 */
 function column_getToggleVisibilityHandler(column) {
@@ -75,13 +80,14 @@ function column_getToggleVisibilityHandler(column) {
 	};
 }
 /**
-* Returns visible cells for a row.
+* Collects the cells from this row whose columns are visible.
 *
-* This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+* When column pinning is active, the result is ordered as left-pinned cells,
+* center cells, then right-pinned cells.
 *
 * @example
 * ```ts
-* const value = row_getVisibleCells(row)
+* const visibleCells = row_getVisibleCells(row)
 * ```
 */
 function row_getVisibleCells(row) {
@@ -118,13 +124,13 @@ function row_getVisibleCells(row) {
 	];
 }
 /**
-* Returns visible cells by column id for a row.
+* Builds a lookup map of this row's visible cells keyed by column id.
 *
-* This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+* Hidden columns are omitted from the map.
 *
 * @example
 * ```ts
-* const value = row_getVisibleCellsByColumnId(row)
+* const visibleCellsById = row_getVisibleCellsByColumnId(row)
 * ```
 */
 function row_getVisibleCellsByColumnId(row) {
@@ -137,39 +143,42 @@ function row_getVisibleCellsByColumnId(row) {
 	return result;
 }
 /**
-* Returns visible flat columns for the table.
+* Filters the flat column list down to visible columns.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Parent/group columns are included when `column_getIsVisible` considers them
+* visible.
 *
 * @example
 * ```ts
-* const value = table_getVisibleFlatColumns(table)
+* const columns = table_getVisibleFlatColumns(table)
 * ```
 */
 function table_getVisibleFlatColumns(table) {
 	return table.getAllFlatColumns().filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
 }
 /**
-* Returns visible leaf columns for the table.
+* Filters leaf columns down to those currently visible.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* This is the column list most row rendering code uses before pinning-specific
+* partitioning.
 *
 * @example
 * ```ts
-* const value = table_getVisibleLeafColumns(table)
+* const columns = table_getVisibleLeafColumns(table)
 * ```
 */
 function table_getVisibleLeafColumns(table) {
 	return table.getAllLeafColumns().filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
 }
 /**
-* Updates the table's column visibility state slice.
+* Routes a column visibility updater through the table's visibility change handler.
 *
-* The updater follows TanStack Table updater semantics and is routed through the corresponding `on*Change` option or backing atom.
+* The updater may be a next visibility map or a function of the previous map,
+* matching the instance `table.setColumnVisibility` behavior.
 *
 * @example
 * ```ts
-* table_setColumnVisibility(table, (old) => old)
+* table_setColumnVisibility(table, (old) => ({ ...old, age: false }))
 * ```
 */
 function table_setColumnVisibility(table, updater) {
@@ -177,9 +186,10 @@ function table_setColumnVisibility(table, updater) {
 	(_table$options$onColu = (_table$options = table.options).onColumnVisibilityChange) === null || _table$options$onColu === void 0 || _table$options$onColu.call(_table$options, updater);
 }
 /**
-* Resets the table's column visibility state slice.
+* Resets `columnVisibility` to the configured initial state or feature default.
 *
-* By default the reset uses `table.initialState`; when supported, a blank/default reset bypasses the saved initial value.
+* With no argument, the reset clones `table.initialState.columnVisibility` when
+* it exists. Passing `true` ignores initial state and resets to `{}`.
 *
 * @example
 * ```ts
@@ -191,9 +201,9 @@ function table_resetColumnVisibility(table, defaultState) {
 	table_setColumnVisibility(table, defaultState ? {} : require_utils.cloneState(table.initialState.columnVisibility ?? {}));
 }
 /**
-* Toggles all columns visible for the table.
+* Shows or hides every hideable leaf column.
 *
-* This is the table-level convenience API used by UI controls that affect many columns or rows at once.
+* Columns that cannot hide stay visible when toggling all columns off.
 *
 * @example
 * ```ts
@@ -211,39 +221,41 @@ function table_toggleAllColumnsVisible(table, value) {
 	table_setColumnVisibility(table, visibility);
 }
 /**
-* Returns is all columns visible for the table.
+* Checks whether every leaf column is currently visible.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Non-hideable columns are naturally visible because missing visibility entries
+* default to `true`.
 *
 * @example
 * ```ts
-* const value = table_getIsAllColumnsVisible(table)
+* const allVisible = table_getIsAllColumnsVisible(table)
 * ```
 */
 function table_getIsAllColumnsVisible(table) {
 	return !table.getAllLeafColumns().some((column) => !require_utils.callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
 }
 /**
-* Returns is some columns visible for the table.
+* Checks whether at least one leaf column is currently visible.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* This is useful for tri-state "show all columns" controls.
 *
 * @example
 * ```ts
-* const value = table_getIsSomeColumnsVisible(table)
+* const someVisible = table_getIsSomeColumnsVisible(table)
 * ```
 */
 function table_getIsSomeColumnsVisible(table) {
 	return table.getAllLeafColumns().some((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
 }
 /**
-* Returns an event handler for all columns visibility handler.
+* Creates a checkbox-style handler that shows or hides all columns.
 *
-* The handler calls the matching table toggle API and can be attached directly to checkbox or button UI.
+* The handler reads `event.target.checked`, so it is intended for controls whose
+* checked state means "all columns visible".
 *
 * @example
 * ```ts
-* const value = table_getToggleAllColumnsVisibilityHandler(table)
+* const onChange = table_getToggleAllColumnsVisibilityHandler(table)
 * ```
 */
 function table_getToggleAllColumnsVisibilityHandler(table) {

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

@@ -1 +1 @@
-{"version":3,"file":"columnVisibilityFeature.utils.cjs","names":["callMemoOrStaticFn","getDefaultColumnPinningState","cloneState"],"sources":["../../../src/features/column-visibility/columnVisibilityFeature.utils.ts"],"sourcesContent":["import { callMemoOrStaticFn, cloneState } 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 * Returns the default column visibility state.\n *\n * Feature constructors use this value to initialize the table state or option defaults when no user value is provided.\n *\n * @example\n * ```ts\n * const initialValue = getDefaultColumnVisibilityState()\n * ```\n */\nexport function getDefaultColumnVisibilityState(): ColumnVisibilityState {\n  return {}\n}\n\n/**\n * Toggles visibility for a column.\n *\n * The update is applied through the owning table state slice and respects the feature options for that column.\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      ...old,\n      [column.id]:\n        visible ??\n        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\n    }))\n  }\n}\n\n/**\n * Returns is visible for a column.\n *\n * This derives the value from the column definition, table options, and the feature state atoms registered on the table.\n *\n * @example\n * ```ts\n * const value = column_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  return (\n    (childColumns.length\n      ? childColumns.some((childColumn) =>\n          callMemoOrStaticFn(childColumn, 'getIsVisible', column_getIsVisible),\n        )\n      : column.table.atoms.columnVisibility?.get()?.[column.id]) ?? true\n  )\n}\n\n/**\n * Returns whether a column can use hide.\n *\n * This combines column options, table options, and any required accessor or feature state for the capability.\n *\n * @example\n * ```ts\n * const value = 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 * Returns an event handler for toggling visibility handler.\n *\n * The handler is intended for direct use in column header controls such as buttons or checkboxes.\n *\n * @example\n * ```ts\n * const value = 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 * Returns visible cells for a row.\n *\n * This is the static implementation behind the matching row instance API and may read row caches or table state atoms.\n *\n * @example\n * ```ts\n * const value = 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 * Returns visible cells by column id for a row.\n *\n * This is the static implementation behind the matching row instance API and may read row caches or table state atoms.\n *\n * @example\n * ```ts\n * const value = 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: Record<string, 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 * Returns visible flat columns for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_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 * Returns visible leaf columns for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_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 * Updates the table's column visibility state slice.\n *\n * The updater follows TanStack Table updater semantics and is routed through the corresponding `on*Change` option or backing atom.\n *\n * @example\n * ```ts\n * table_setColumnVisibility(table, (old) => old)\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 the table's column visibility state slice.\n *\n * By default the reset uses `table.initialState`; when supported, a blank/default reset bypasses the saved initial value.\n *\n * @example\n * ```ts\n * table_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 ? {} : cloneState(table.initialState.columnVisibility ?? {}),\n  )\n}\n\n/**\n * Toggles all columns visible for the table.\n *\n * This is the table-level convenience API used by UI controls that affect many columns or rows at once.\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: Record<string, 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 * Returns is all columns visible for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_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 * Returns is some columns visible for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_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 * Returns an event handler for all columns visibility handler.\n *\n * The handler calls the matching table toggle API and can be attached directly to checkbox or button UI.\n *\n * @example\n * ```ts\n * const value = 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":["callMemoOrStaticFn","getDefaultColumnPinningState","cloneState"],"sources":["../../../src/features/column-visibility/columnVisibilityFeature.utils.ts"],"sourcesContent":["import { callMemoOrStaticFn, cloneState } 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 {}\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      ...old,\n      [column.id]:\n        visible ??\n        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),\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  return (\n    (childColumns.length\n      ? childColumns.some((childColumn) =>\n          callMemoOrStaticFn(childColumn, 'getIsVisible', column_getIsVisible),\n        )\n      : column.table.atoms.columnVisibility?.get()?.[column.id]) ?? 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: Record<string, 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 ? {} : cloneState(table.initialState.columnVisibility ?? {}),\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: Record<string, 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.d.cts

@@ -7,20 +7,22 @@ import { Table_Internal } from "../../types/Table.cjs";
 import { Cell } from "../../types/Cell.cjs";
 //#region src/features/column-visibility/columnVisibilityFeature.utils.d.ts
 /**
- * Returns the default column visibility state.
+ * Creates the default column visibility state.
  *
- * Feature constructors use this value to initialize the table state or option defaults when no user value is provided.
+ * The feature default is an empty object, where missing column ids are treated
+ * as visible. Reset APIs use this value when `defaultState` is `true`.
  *
  * @example
  * ```ts
- * const initialValue = getDefaultColumnVisibilityState()
+ * const visibility = getDefaultColumnVisibilityState()
  * ```
  */
 declare function getDefaultColumnVisibilityState(): ColumnVisibilityState;
 /**
- * Toggles visibility for a column.
+ * Updates this column's visibility when hiding is allowed.
  *
- * The update is applied through the owning table state slice and respects the feature options for that column.
+ * Passing `visible` stores that value. Omitting it flips the column's current
+ * visibility state. Columns that cannot hide are left unchanged.
  *
  * @example
  * ```ts
@@ -29,97 +31,105 @@ declare function getDefaultColumnVisibilityState(): ColumnVisibilityState;
  */
 declare function column_toggleVisibility<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>, visible?: boolean): void;
 /**
- * Returns is visible for a column.
+ * Checks whether this column is visible.
  *
- * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ * Leaf columns read `state.columnVisibility[column.id]`, where missing entries
+ * default to visible. Parent columns are visible when at least one child column
+ * is visible.
  *
  * @example
  * ```ts
- * const value = column_getIsVisible(column)
+ * const visible = column_getIsVisible(column)
  * ```
  */
 declare function column_getIsVisible<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
 /**
- * Returns whether a column can use hide.
+ * Checks whether this column is allowed to be hidden.
  *
- * This combines column options, table options, and any required accessor or feature state for the capability.
+ * Both `columnDef.enableHiding` and table `enableHiding` default to `true`.
  *
  * @example
  * ```ts
- * const value = column_getCanHide(column)
+ * const canHide = column_getCanHide(column)
  * ```
  */
 declare function column_getCanHide<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
 /**
- * Returns an event handler for toggling visibility handler.
+ * Creates a checkbox-style handler that writes this column's visibility.
  *
- * The handler is intended for direct use in column header controls such as buttons or checkboxes.
+ * The handler reads `event.target.checked`, so it is intended for visibility
+ * controls whose checked state means "visible".
  *
  * @example
  * ```ts
- * const value = column_getToggleVisibilityHandler(column)
+ * const onChange = column_getToggleVisibilityHandler(column)
  * ```
  */
 declare function column_getToggleVisibilityHandler<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): (e: unknown) => void;
 /**
- * Returns visible cells for a row.
+ * Collects the cells from this row whose columns are visible.
  *
- * This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+ * When column pinning is active, the result is ordered as left-pinned cells,
+ * center cells, then right-pinned cells.
  *
  * @example
  * ```ts
- * const value = row_getVisibleCells(row)
+ * const visibleCells = row_getVisibleCells(row)
  * ```
  */
 declare function row_getVisibleCells<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>>;
 /**
- * Returns visible cells by column id for a row.
+ * Builds a lookup map of this row's visible cells keyed by column id.
  *
- * This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+ * Hidden columns are omitted from the map.
  *
  * @example
  * ```ts
- * const value = row_getVisibleCellsByColumnId(row)
+ * const visibleCellsById = row_getVisibleCellsByColumnId(row)
  * ```
  */
 declare function row_getVisibleCellsByColumnId<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): Record<string, Cell<TFeatures, TData, unknown>>;
 /**
- * Returns visible flat columns for the table.
+ * Filters the flat column list down to visible columns.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * Parent/group columns are included when `column_getIsVisible` considers them
+ * visible.
  *
  * @example
  * ```ts
- * const value = table_getVisibleFlatColumns(table)
+ * const columns = table_getVisibleFlatColumns(table)
  * ```
  */
 declare function table_getVisibleFlatColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Column<TFeatures, TData, unknown>[];
 /**
- * Returns visible leaf columns for the table.
+ * Filters leaf columns down to those currently visible.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * This is the column list most row rendering code uses before pinning-specific
+ * partitioning.
  *
  * @example
  * ```ts
- * const value = table_getVisibleLeafColumns(table)
+ * const columns = table_getVisibleLeafColumns(table)
  * ```
  */
 declare function table_getVisibleLeafColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Column<TFeatures, TData, unknown>[];
 /**
- * Updates the table's column visibility state slice.
+ * Routes a column visibility updater through the table's visibility change handler.
  *
- * The updater follows TanStack Table updater semantics and is routed through the corresponding `on*Change` option or backing atom.
+ * The updater may be a next visibility map or a function of the previous map,
+ * matching the instance `table.setColumnVisibility` behavior.
  *
  * @example
  * ```ts
- * table_setColumnVisibility(table, (old) => old)
+ * table_setColumnVisibility(table, (old) => ({ ...old, age: false }))
  * ```
  */
 declare function table_setColumnVisibility<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<ColumnVisibilityState>): void;
 /**
- * Resets the table's column visibility state slice.
+ * Resets `columnVisibility` to the configured initial state or feature default.
  *
- * By default the reset uses `table.initialState`; when supported, a blank/default reset bypasses the saved initial value.
+ * With no argument, the reset clones `table.initialState.columnVisibility` when
+ * it exists. Passing `true` ignores initial state and resets to `{}`.
  *
  * @example
  * ```ts
@@ -129,9 +139,9 @@ declare function table_setColumnVisibility<TFeatures extends TableFeatures, TDat
  */
 declare function table_resetColumnVisibility<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
 /**
- * Toggles all columns visible for the table.
+ * Shows or hides every hideable leaf column.
  *
- * This is the table-level convenience API used by UI controls that affect many columns or rows at once.
+ * Columns that cannot hide stay visible when toggling all columns off.
  *
  * @example
  * ```ts
@@ -140,35 +150,37 @@ declare function table_resetColumnVisibility<TFeatures extends TableFeatures, TD
  */
 declare function table_toggleAllColumnsVisible<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, value?: boolean): void;
 /**
- * Returns is all columns visible for the table.
+ * Checks whether every leaf column is currently visible.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * Non-hideable columns are naturally visible because missing visibility entries
+ * default to `true`.
  *
  * @example
  * ```ts
- * const value = table_getIsAllColumnsVisible(table)
+ * const allVisible = table_getIsAllColumnsVisible(table)
  * ```
  */
 declare function table_getIsAllColumnsVisible<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
 /**
- * Returns is some columns visible for the table.
+ * Checks whether at least one leaf column is currently visible.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * This is useful for tri-state "show all columns" controls.
  *
  * @example
  * ```ts
- * const value = table_getIsSomeColumnsVisible(table)
+ * const someVisible = table_getIsSomeColumnsVisible(table)
  * ```
  */
 declare function table_getIsSomeColumnsVisible<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
 /**
- * Returns an event handler for all columns visibility handler.
+ * Creates a checkbox-style handler that shows or hides all columns.
  *
- * The handler calls the matching table toggle API and can be attached directly to checkbox or button UI.
+ * The handler reads `event.target.checked`, so it is intended for controls whose
+ * checked state means "all columns visible".
  *
  * @example
  * ```ts
- * const value = table_getToggleAllColumnsVisibilityHandler(table)
+ * const onChange = table_getToggleAllColumnsVisibilityHandler(table)
  * ```
  */
 declare function table_getToggleAllColumnsVisibilityHandler<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): (e: unknown) => void;