@tanstack/table-core 9.0.0-alpha.8 → 9.0.0-beta.10

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

@@ -0,0 +1,94 @@
+import { assignPrototypeAPIs, assignTableAPIs, makeStateUpdater } from "../../utils.js";
+import { column_getCanHide, column_getIsVisible, column_getToggleVisibilityHandler, column_toggleVisibility, getDefaultColumnVisibilityState, row_getVisibleCells, row_getVisibleCellsByColumnId, table_getIsAllColumnsVisible, table_getIsSomeColumnsVisible, table_getToggleAllColumnsVisibilityHandler, table_getVisibleFlatColumns, table_getVisibleLeafColumns, table_resetColumnVisibility, table_setColumnVisibility, table_toggleAllColumnsVisible } from "./columnVisibilityFeature.utils.js";
+
+//#region src/features/column-visibility/columnVisibilityFeature.ts
+/**
+* Feature that adds column visibility state and APIs for hiding and showing columns.
+*/
+const columnVisibilityFeature = {
+	getInitialState: (initialState) => {
+		return {
+			columnVisibility: getDefaultColumnVisibilityState(),
+			...initialState
+		};
+	},
+	getDefaultTableOptions: (table) => {
+		return { onColumnVisibilityChange: makeStateUpdater("columnVisibility", table) };
+	},
+	assignColumnPrototype: (prototype, table) => {
+		assignPrototypeAPIs("columnVisibilityFeature", prototype, table, {
+			column_getIsVisible: {
+				fn: (column) => column_getIsVisible(column),
+				memoDeps: (column) => {
+					var _table$atoms$columnVi;
+					return [
+						table.options.columns,
+						(_table$atoms$columnVi = table.atoms.columnVisibility) === null || _table$atoms$columnVi === void 0 ? void 0 : _table$atoms$columnVi.get(),
+						column.columns
+					];
+				}
+			},
+			column_getCanHide: { fn: (column) => column_getCanHide(column) },
+			column_getToggleVisibilityHandler: { fn: (column) => column_getToggleVisibilityHandler(column) },
+			column_toggleVisibility: { fn: (column, visible) => column_toggleVisibility(column, visible) }
+		});
+	},
+	assignRowPrototype: (prototype, table) => {
+		assignPrototypeAPIs("columnVisibilityFeature", prototype, table, {
+			row_getVisibleCells: {
+				fn: (row) => row_getVisibleCells(row),
+				memoDeps: (row) => {
+					var _table$atoms$columnPi, _table$atoms$columnVi2;
+					return [
+						row.getAllCells(),
+						(_table$atoms$columnPi = table.atoms.columnPinning) === null || _table$atoms$columnPi === void 0 ? void 0 : _table$atoms$columnPi.get(),
+						(_table$atoms$columnVi2 = table.atoms.columnVisibility) === null || _table$atoms$columnVi2 === void 0 ? void 0 : _table$atoms$columnVi2.get()
+					];
+				}
+			},
+			row_getVisibleCellsByColumnId: {
+				fn: (row) => row_getVisibleCellsByColumnId(row),
+				memoDeps: (row) => {
+					var _table$atoms$columnVi3;
+					return [row.getAllCells(), (_table$atoms$columnVi3 = table.atoms.columnVisibility) === null || _table$atoms$columnVi3 === void 0 ? void 0 : _table$atoms$columnVi3.get()];
+				}
+			}
+		});
+	},
+	constructTableAPIs: (table) => {
+		assignTableAPIs("columnVisibilityFeature", table, {
+			table_getVisibleFlatColumns: {
+				fn: () => table_getVisibleFlatColumns(table),
+				memoDeps: () => {
+					var _table$atoms$columnVi4, _table$atoms$columnOr;
+					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_getVisibleLeafColumns: {
+				fn: () => table_getVisibleLeafColumns(table),
+				memoDeps: () => {
+					var _table$atoms$columnVi5, _table$atoms$columnOr2;
+					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_setColumnVisibility: { fn: (updater) => table_setColumnVisibility(table, updater) },
+			table_resetColumnVisibility: { fn: (defaultState) => table_resetColumnVisibility(table, defaultState) },
+			table_toggleAllColumnsVisible: { fn: (value) => table_toggleAllColumnsVisible(table, value) },
+			table_getIsAllColumnsVisible: { fn: () => table_getIsAllColumnsVisible(table) },
+			table_getIsSomeColumnsVisible: { fn: () => table_getIsSomeColumnsVisible(table) },
+			table_getToggleAllColumnsVisibilityHandler: { fn: () => table_getToggleAllColumnsVisibilityHandler(table) }
+		});
+	}
+};
+
+//#endregion
+export { columnVisibilityFeature };
+//# sourceMappingURL=columnVisibilityFeature.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,97 @@
+import { OnChangeFn, RowData, Updater } from "../../types/type-utils.cjs";
+import { Column } from "../../types/Column.cjs";
+import { TableFeatures } from "../../types/TableFeatures.cjs";
+import { Cell } from "../../types/Cell.cjs";
+
+//#region src/features/column-visibility/columnVisibilityFeature.types.d.ts
+type ColumnVisibilityState = Record<string, boolean>;
+interface TableState_ColumnVisibility {
+  columnVisibility: ColumnVisibilityState;
+}
+interface TableOptions_ColumnVisibility {
+  /**
+   * Whether to enable column hiding. Defaults to `true`.
+   */
+  enableHiding?: boolean;
+  /**
+   * Called with an updater when column visibility state changes. Pair this with
+   * `state.columnVisibility` when using external state; external atoms can own
+   * the slice without this callback.
+   */
+  onColumnVisibilityChange?: OnChangeFn<ColumnVisibilityState>;
+}
+type VisibilityDefaultOptions = Pick<TableOptions_ColumnVisibility, 'onColumnVisibilityChange'>;
+interface Table_ColumnVisibility<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Checks whether every leaf column is currently visible.
+   */
+  getIsAllColumnsVisible: () => boolean;
+  /**
+   * Checks whether at least one leaf column is currently visible.
+   */
+  getIsSomeColumnsVisible: () => boolean;
+  /**
+   * Creates a checkbox-style handler that shows or hides all columns.
+   */
+  getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
+  /**
+   * Lists visible columns in flat table order, including parent columns that
+   * have visible descendants.
+   */
+  getVisibleFlatColumns: () => Array<Column<TFeatures, TData, unknown>>;
+  /**
+   * Lists visible leaf columns in the order used for row cells and headers.
+   */
+  getVisibleLeafColumns: () => Array<Column<TFeatures, TData, unknown>>;
+  /**
+   * Resets `columnVisibility` to `initialState.columnVisibility`.
+   *
+   * Pass `true` to ignore initial state and reset to `{}`.
+   */
+  resetColumnVisibility: (defaultState?: boolean) => void;
+  /**
+   * Updates column visibility state with a next map or updater function.
+   */
+  setColumnVisibility: (updater: Updater<ColumnVisibilityState>) => void;
+  /**
+   * Toggles the visibility of all columns.
+   */
+  toggleAllColumnsVisible: (value?: boolean) => void;
+}
+interface ColumnDef_ColumnVisibility {
+  /**
+   * Allows this column to be hidden. Defaults to `true`.
+   */
+  enableHiding?: boolean;
+}
+interface Row_ColumnVisibility<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Gets this row's cells for currently visible columns.
+   */
+  getVisibleCells: () => Array<Cell<TFeatures, TData, unknown>>;
+  /**
+   * Maps this row's currently visible cells by column id.
+   */
+  getVisibleCellsByColumnId: () => Record<string, Cell<TFeatures, TData, unknown>>;
+}
+interface Column_ColumnVisibility {
+  /**
+   * Checks whether this column is allowed to be hidden.
+   */
+  getCanHide: () => boolean;
+  /**
+   * Checks whether this column is currently visible.
+   */
+  getIsVisible: () => boolean;
+  /**
+   * Creates a checkbox-style handler that toggles this column's visibility.
+   */
+  getToggleVisibilityHandler: () => (event: unknown) => void;
+  /**
+   * Toggles the visibility of the column.
+   */
+  toggleVisibility: (value?: boolean) => void;
+}
+//#endregion
+export { ColumnDef_ColumnVisibility, ColumnVisibilityState, Column_ColumnVisibility, Row_ColumnVisibility, TableOptions_ColumnVisibility, TableState_ColumnVisibility, Table_ColumnVisibility, VisibilityDefaultOptions };
+//# sourceMappingURL=columnVisibilityFeature.types.d.cts.map

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

@@ -0,0 +1,97 @@
+import { OnChangeFn, RowData, Updater } from "../../types/type-utils.js";
+import { Column } from "../../types/Column.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+import { Cell } from "../../types/Cell.js";
+
+//#region src/features/column-visibility/columnVisibilityFeature.types.d.ts
+type ColumnVisibilityState = Record<string, boolean>;
+interface TableState_ColumnVisibility {
+  columnVisibility: ColumnVisibilityState;
+}
+interface TableOptions_ColumnVisibility {
+  /**
+   * Whether to enable column hiding. Defaults to `true`.
+   */
+  enableHiding?: boolean;
+  /**
+   * Called with an updater when column visibility state changes. Pair this with
+   * `state.columnVisibility` when using external state; external atoms can own
+   * the slice without this callback.
+   */
+  onColumnVisibilityChange?: OnChangeFn<ColumnVisibilityState>;
+}
+type VisibilityDefaultOptions = Pick<TableOptions_ColumnVisibility, 'onColumnVisibilityChange'>;
+interface Table_ColumnVisibility<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Checks whether every leaf column is currently visible.
+   */
+  getIsAllColumnsVisible: () => boolean;
+  /**
+   * Checks whether at least one leaf column is currently visible.
+   */
+  getIsSomeColumnsVisible: () => boolean;
+  /**
+   * Creates a checkbox-style handler that shows or hides all columns.
+   */
+  getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
+  /**
+   * Lists visible columns in flat table order, including parent columns that
+   * have visible descendants.
+   */
+  getVisibleFlatColumns: () => Array<Column<TFeatures, TData, unknown>>;
+  /**
+   * Lists visible leaf columns in the order used for row cells and headers.
+   */
+  getVisibleLeafColumns: () => Array<Column<TFeatures, TData, unknown>>;
+  /**
+   * Resets `columnVisibility` to `initialState.columnVisibility`.
+   *
+   * Pass `true` to ignore initial state and reset to `{}`.
+   */
+  resetColumnVisibility: (defaultState?: boolean) => void;
+  /**
+   * Updates column visibility state with a next map or updater function.
+   */
+  setColumnVisibility: (updater: Updater<ColumnVisibilityState>) => void;
+  /**
+   * Toggles the visibility of all columns.
+   */
+  toggleAllColumnsVisible: (value?: boolean) => void;
+}
+interface ColumnDef_ColumnVisibility {
+  /**
+   * Allows this column to be hidden. Defaults to `true`.
+   */
+  enableHiding?: boolean;
+}
+interface Row_ColumnVisibility<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Gets this row's cells for currently visible columns.
+   */
+  getVisibleCells: () => Array<Cell<TFeatures, TData, unknown>>;
+  /**
+   * Maps this row's currently visible cells by column id.
+   */
+  getVisibleCellsByColumnId: () => Record<string, Cell<TFeatures, TData, unknown>>;
+}
+interface Column_ColumnVisibility {
+  /**
+   * Checks whether this column is allowed to be hidden.
+   */
+  getCanHide: () => boolean;
+  /**
+   * Checks whether this column is currently visible.
+   */
+  getIsVisible: () => boolean;
+  /**
+   * Creates a checkbox-style handler that toggles this column's visibility.
+   */
+  getToggleVisibilityHandler: () => (event: unknown) => void;
+  /**
+   * Toggles the visibility of the column.
+   */
+  toggleVisibility: (value?: boolean) => void;
+}
+//#endregion
+export { ColumnDef_ColumnVisibility, ColumnVisibilityState, Column_ColumnVisibility, Row_ColumnVisibility, TableOptions_ColumnVisibility, TableState_ColumnVisibility, Table_ColumnVisibility, VisibilityDefaultOptions };
+//# sourceMappingURL=columnVisibilityFeature.types.d.ts.map

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

@@ -0,0 +1,283 @@
+const require_utils = require('../../utils.cjs');
+const require_columnPinningFeature_utils = require('../column-pinning/columnPinningFeature.utils.cjs');
+
+//#region src/features/column-visibility/columnVisibilityFeature.utils.ts
+/**
+* Creates the default column visibility state.
+*
+* 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 visibility = getDefaultColumnVisibilityState()
+* ```
+*/
+function getDefaultColumnVisibilityState() {
+	return {};
+}
+/**
+* Updates this column's visibility when hiding is allowed.
+*
+* Passing `visible` stores that value. Omitting it flips the column's current
+* visibility state. Columns that cannot hide are left unchanged.
+*
+* @example
+* ```ts
+* column_toggleVisibility(column)
+* ```
+*/
+function column_toggleVisibility(column, visible) {
+	if (column_getCanHide(column)) table_setColumnVisibility(column.table, (old) => ({
+		...old,
+		[column.id]: visible ?? !require_utils.callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible)
+	}));
+}
+/**
+* Checks whether this column is visible.
+*
+* 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 visible = column_getIsVisible(column)
+* ```
+*/
+function column_getIsVisible(column) {
+	var _column$table$atoms$c;
+	const childColumns = column.columns;
+	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;
+}
+/**
+* Checks whether this column is allowed to be hidden.
+*
+* Both `columnDef.enableHiding` and table `enableHiding` default to `true`.
+*
+* @example
+* ```ts
+* const canHide = column_getCanHide(column)
+* ```
+*/
+function column_getCanHide(column) {
+	return (column.columnDef.enableHiding ?? true) && (column.table.options.enableHiding ?? true);
+}
+/**
+* Creates a checkbox-style handler that writes this column's visibility.
+*
+* The handler reads `event.target.checked`, so it is intended for visibility
+* controls whose checked state means "visible".
+*
+* @example
+* ```ts
+* const onChange = column_getToggleVisibilityHandler(column)
+* ```
+*/
+function column_getToggleVisibilityHandler(column) {
+	return (e) => {
+		column_toggleVisibility(column, e.target.checked);
+	};
+}
+/**
+* Collects the cells from this row whose columns are visible.
+*
+* When column pinning is active, the result is ordered as left-pinned cells,
+* center cells, then right-pinned cells.
+*
+* @example
+* ```ts
+* const visibleCells = row_getVisibleCells(row)
+* ```
+*/
+function row_getVisibleCells(row) {
+	var _row$table$atoms$colu;
+	const allCells = row.getAllCells();
+	const visibleCells = [];
+	for (let i = 0; i < allCells.length; i++) {
+		const cell = allCells[i];
+		if (require_utils.callMemoOrStaticFn(cell.column, "getIsVisible", column_getIsVisible)) visibleCells.push(cell);
+	}
+	const { left, right } = ((_row$table$atoms$colu = row.table.atoms.columnPinning) === null || _row$table$atoms$colu === void 0 ? void 0 : _row$table$atoms$colu.get()) ?? require_columnPinningFeature_utils.getDefaultColumnPinningState();
+	if (!left.length && !right.length) return visibleCells;
+	const visibleCellsByColumnId = require_utils.callMemoOrStaticFn(row, "getVisibleCellsByColumnId", row_getVisibleCellsByColumnId);
+	const leftCells = [];
+	for (let i = 0; i < left.length; i++) {
+		const cell = visibleCellsByColumnId[left[i]];
+		if (cell) leftCells.push(cell);
+	}
+	const rightCells = [];
+	for (let i = 0; i < right.length; i++) {
+		const cell = visibleCellsByColumnId[right[i]];
+		if (cell) rightCells.push(cell);
+	}
+	const centerCells = [];
+	for (let i = 0; i < visibleCells.length; i++) {
+		const cell = visibleCells[i];
+		const id = cell.column.id;
+		if (!left.includes(id) && !right.includes(id)) centerCells.push(cell);
+	}
+	return [
+		...leftCells,
+		...centerCells,
+		...rightCells
+	];
+}
+/**
+* Builds a lookup map of this row's visible cells keyed by column id.
+*
+* Hidden columns are omitted from the map.
+*
+* @example
+* ```ts
+* const visibleCellsById = row_getVisibleCellsByColumnId(row)
+* ```
+*/
+function row_getVisibleCellsByColumnId(row) {
+	const result = {};
+	const allCells = row.getAllCells();
+	for (let i = 0; i < allCells.length; i++) {
+		const cell = allCells[i];
+		if (require_utils.callMemoOrStaticFn(cell.column, "getIsVisible", column_getIsVisible)) result[cell.column.id] = cell;
+	}
+	return result;
+}
+/**
+* Filters the flat column list down to visible columns.
+*
+* Parent/group columns are included when `column_getIsVisible` considers them
+* visible.
+*
+* @example
+* ```ts
+* const columns = table_getVisibleFlatColumns(table)
+* ```
+*/
+function table_getVisibleFlatColumns(table) {
+	return table.getAllFlatColumns().filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
+}
+/**
+* Filters leaf columns down to those currently visible.
+*
+* This is the column list most row rendering code uses before pinning-specific
+* partitioning.
+*
+* @example
+* ```ts
+* const columns = table_getVisibleLeafColumns(table)
+* ```
+*/
+function table_getVisibleLeafColumns(table) {
+	return table.getAllLeafColumns().filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
+}
+/**
+* Routes a column visibility updater through the table's visibility change handler.
+*
+* 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, age: false }))
+* ```
+*/
+function table_setColumnVisibility(table, updater) {
+	var _table$options$onColu, _table$options;
+	(_table$options$onColu = (_table$options = table.options).onColumnVisibilityChange) === null || _table$options$onColu === void 0 || _table$options$onColu.call(_table$options, updater);
+}
+/**
+* Resets `columnVisibility` to the configured initial state or feature default.
+*
+* With no argument, the reset clones `table.initialState.columnVisibility` when
+* it exists. Passing `true` ignores initial state and resets to `{}`.
+*
+* @example
+* ```ts
+* table_resetColumnVisibility(table)
+* table_resetColumnVisibility(table, true)
+* ```
+*/
+function table_resetColumnVisibility(table, defaultState) {
+	table_setColumnVisibility(table, defaultState ? {} : require_utils.cloneState(table.initialState.columnVisibility ?? {}));
+}
+/**
+* Shows or hides every hideable leaf column.
+*
+* Columns that cannot hide stay visible when toggling all columns off.
+*
+* @example
+* ```ts
+* table_toggleAllColumnsVisible(table)
+* ```
+*/
+function table_toggleAllColumnsVisible(table, value) {
+	value = value ?? !table_getIsAllColumnsVisible(table);
+	const visibility = {};
+	const leafColumns = table.getAllLeafColumns();
+	for (let i = 0; i < leafColumns.length; i++) {
+		const column = leafColumns[i];
+		visibility[column.id] = !value ? !column_getCanHide(column) : value;
+	}
+	table_setColumnVisibility(table, visibility);
+}
+/**
+* Checks whether every leaf column is currently visible.
+*
+* Non-hideable columns are naturally visible because missing visibility entries
+* default to `true`.
+*
+* @example
+* ```ts
+* const allVisible = table_getIsAllColumnsVisible(table)
+* ```
+*/
+function table_getIsAllColumnsVisible(table) {
+	return !table.getAllLeafColumns().some((column) => !require_utils.callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
+}
+/**
+* Checks whether at least one leaf column is currently visible.
+*
+* This is useful for tri-state "show all columns" controls.
+*
+* @example
+* ```ts
+* const someVisible = table_getIsSomeColumnsVisible(table)
+* ```
+*/
+function table_getIsSomeColumnsVisible(table) {
+	return table.getAllLeafColumns().some((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
+}
+/**
+* Creates a checkbox-style handler that shows or hides all columns.
+*
+* The handler reads `event.target.checked`, so it is intended for controls whose
+* checked state means "all columns visible".
+*
+* @example
+* ```ts
+* const onChange = table_getToggleAllColumnsVisibilityHandler(table)
+* ```
+*/
+function table_getToggleAllColumnsVisibilityHandler(table) {
+	return (e) => {
+		table_toggleAllColumnsVisible(table, e.target.checked);
+	};
+}
+
+//#endregion
+exports.column_getCanHide = column_getCanHide;
+exports.column_getIsVisible = column_getIsVisible;
+exports.column_getToggleVisibilityHandler = column_getToggleVisibilityHandler;
+exports.column_toggleVisibility = column_toggleVisibility;
+exports.getDefaultColumnVisibilityState = getDefaultColumnVisibilityState;
+exports.row_getVisibleCells = row_getVisibleCells;
+exports.row_getVisibleCellsByColumnId = row_getVisibleCellsByColumnId;
+exports.table_getIsAllColumnsVisible = table_getIsAllColumnsVisible;
+exports.table_getIsSomeColumnsVisible = table_getIsSomeColumnsVisible;
+exports.table_getToggleAllColumnsVisibilityHandler = table_getToggleAllColumnsVisibilityHandler;
+exports.table_getVisibleFlatColumns = table_getVisibleFlatColumns;
+exports.table_getVisibleLeafColumns = table_getVisibleLeafColumns;
+exports.table_resetColumnVisibility = table_resetColumnVisibility;
+exports.table_setColumnVisibility = table_setColumnVisibility;
+exports.table_toggleAllColumnsVisible = table_toggleAllColumnsVisible;
+//# sourceMappingURL=columnVisibilityFeature.utils.cjs.map

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

@@ -0,0 +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 * 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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"}