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

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

@@ -1 +0,0 @@
-{"version":3,"file":"columnSizingFeature.utils.js","names":[],"sources":["../../../src/features/column-sizing/columnSizingFeature.utils.ts"],"sourcesContent":["import {\n  table_getCenterHeaderGroups,\n  table_getEndHeaderGroups,\n  table_getPinnedVisibleLeafColumns,\n  table_getStartHeaderGroups,\n} from '../column-pinning/columnPinningFeature.utils'\nimport {\n  callMemoOrStaticFn,\n  cloneState,\n  hasOwn,\n  makeObjectMap,\n} from '../../utils'\nimport type { ColumnPinningPosition } from '../column-pinning/columnPinningFeature.types'\nimport type { CellData, RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Header } from '../../types/Header'\nimport type { Column_Internal } from '../../types/Column'\nimport type {\n  ColumnOffsets,\n  ColumnOffsetsByPosition,\n  ColumnSizingState,\n} from './columnSizingFeature.types'\n\n/**\n * Creates the default committed column sizing state.\n *\n * The feature default is an empty map, so columns fall back to their column def\n * size or the built-in sizing defaults.\n *\n * @example\n * ```ts\n * const sizing = getDefaultColumnSizingState()\n * ```\n */\nexport function getDefaultColumnSizingState(): ColumnSizingState {\n  return makeObjectMap()\n}\n\n/**\n * Creates the built-in sizing defaults for column definitions.\n *\n * Columns default to `size: 150`, `minSize: 20`, and\n * `maxSize: Number.MAX_SAFE_INTEGER` unless overridden by column definitions or\n * table defaults.\n *\n * @example\n * ```ts\n * const defaults = getDefaultColumnSizingColumnDef()\n * ```\n */\nexport function getDefaultColumnSizingColumnDef() {\n  return {\n    size: 150,\n    minSize: 20,\n    maxSize: Number.MAX_SAFE_INTEGER,\n  }\n}\n\n/**\n * Resolves a column's current pixel size.\n *\n * Committed `state.columnSizing[column.id]` wins over `columnDef.size`, then the\n * built-in default size. The result is clamped between min and max size.\n *\n * @example\n * ```ts\n * const width = column_getSize(column)\n * ```\n */\nexport function column_getSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): number {\n  const defaultSizes = getDefaultColumnSizingColumnDef()\n  const columnSizing = column.table.atoms.columnSizing?.get()\n  const columnSize =\n    columnSizing && hasOwn(columnSizing, column.id)\n      ? columnSizing[column.id]\n      : undefined\n\n  return Math.min(\n    Math.max(\n      column.columnDef.minSize ?? defaultSizes.minSize,\n      columnSize ?? column.columnDef.size ?? defaultSizes.size,\n    ),\n    column.columnDef.maxSize ?? defaultSizes.maxSize,\n  )\n}\n\nfunction buildColumnOffsets<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columns: Array<Column_Internal<TFeatures, TData, unknown>>): ColumnOffsets {\n  const starts = makeObjectMap<number>()\n  const afters = makeObjectMap<number>()\n  const sizes = new Array<number>(columns.length)\n\n  let start = 0\n  for (let i = 0; i < columns.length; i++) {\n    const column = columns[i]!\n    const size = callMemoOrStaticFn(column, 'getSize', column_getSize)\n    sizes[i] = size\n    starts[column.id] = start\n    start += size\n  }\n\n  let after = 0\n  for (let i = columns.length - 1; i >= 0; i--) {\n    afters[columns[i]!.id] = after\n    after += sizes[i]!\n  }\n\n  return { starts, afters }\n}\n\n/**\n * Builds start and after offset maps for every visible leaf column, computed\n * once per pinning region plus the full visible list.\n *\n * A single table-level memo of this result backs all `column.getStart()` and\n * `column.getAfter()` calls with O(1) lookups.\n *\n * @example\n * ```ts\n * const offsets = table_getColumnOffsets(table)\n * const startOffset = offsets.start.starts[column.id]\n * ```\n */\nexport function table_getColumnOffsets<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): ColumnOffsetsByPosition {\n  return {\n    all: buildColumnOffsets(\n      table_getPinnedVisibleLeafColumns(table) as Array<\n        Column_Internal<TFeatures, TData, unknown>\n      >,\n    ),\n    center: buildColumnOffsets(\n      table_getPinnedVisibleLeafColumns(table, 'center') as Array<\n        Column_Internal<TFeatures, TData, unknown>\n      >,\n    ),\n    start: buildColumnOffsets(\n      table_getPinnedVisibleLeafColumns(table, 'start') as Array<\n        Column_Internal<TFeatures, TData, unknown>\n      >,\n    ),\n    end: buildColumnOffsets(\n      table_getPinnedVisibleLeafColumns(table, 'end') as Array<\n        Column_Internal<TFeatures, TData, unknown>\n      >,\n    ),\n  }\n}\n\nfunction toOffsetsKey(\n  position: ColumnPinningPosition | 'center' | undefined,\n): keyof ColumnOffsetsByPosition {\n  return position === 'start'\n    ? 'start'\n    : position === 'end'\n      ? 'end'\n      : position === 'center'\n        ? 'center'\n        : 'all' // undefined | false use the full visible list\n}\n\n/**\n * Computes the offset from the start edge of a pinning region to this column.\n *\n * The value is the sum of all previous visible leaf column sizes in the\n * requested `'start'`, `'center'`, or `'end'` region.\n *\n * `start` and `end` are logical positions. In LTR languages/layouts, `start`\n * usually corresponds to left and `end` to right. In RTL languages/layouts,\n * `start` usually corresponds to right and `end` to left.\n *\n * @example\n * ```ts\n * const startOffset = column_getStart(column, 'start')\n * ```\n */\nexport function column_getStart<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(\n  column: Column_Internal<TFeatures, TData, TValue>,\n  position?: ColumnPinningPosition | 'center',\n): number {\n  const offsets = callMemoOrStaticFn(\n    column.table,\n    'getColumnOffsets',\n    table_getColumnOffsets,\n  )\n  return offsets[toOffsetsKey(position)].starts[column.id] ?? 0\n}\n\n/**\n * Computes the offset from the end edge of a pinning region after this column.\n *\n * The value is the sum of all following visible leaf column sizes in the\n * requested region.\n *\n * @example\n * ```ts\n * const endOffset = column_getAfter(column, 'end')\n * ```\n */\nexport function column_getAfter<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(\n  column: Column_Internal<TFeatures, TData, TValue>,\n  position?: ColumnPinningPosition | 'center',\n): number {\n  const offsets = callMemoOrStaticFn(\n    column.table,\n    'getColumnOffsets',\n    table_getColumnOffsets,\n  )\n  return offsets[toOffsetsKey(position)].afters[column.id] ?? 0\n}\n\n/**\n * Removes this column's committed size override.\n *\n * After reset, the column resolves size from `columnDef.size` or built-in\n * defaults again.\n *\n * @example\n * ```ts\n * column_resetSize(column)\n * ```\n */\nexport function column_resetSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  table_setColumnSizing(column.table, (old) => {\n    const rest = makeObjectMap<number>()\n    const columnIds = Object.keys(old)\n    for (let i = 0; i < columnIds.length; i++) {\n      const columnId = columnIds[i]!\n      if (columnId !== column.id) {\n        rest[columnId] = old[columnId]!\n      }\n    }\n    return rest\n  })\n}\n\n/**\n * Computes a header's rendered size from its leaf headers.\n *\n * Group headers sum the sizes of all descendant leaf columns. Leaf headers use\n * their column's current size.\n *\n * @example\n * ```ts\n * const width = header_getSize(header)\n * ```\n */\nexport function header_getSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(header: Header<TFeatures, TData, TValue>) {\n  let sum = 0\n\n  const recurse = (h: Header<TFeatures, TData, TValue>) => {\n    if (h.subHeaders.length) {\n      h.subHeaders.forEach(recurse)\n    } else {\n      sum += column_getSize(h.column)\n    }\n  }\n\n  recurse(header)\n\n  return sum\n}\n\n/**\n * Computes a header's offset from the start of its header group.\n *\n * The offset is the previous sibling header's start plus size, or `0` for the\n * first header in the group.\n *\n * @example\n * ```ts\n * const offset = header_getStart(header)\n * ```\n */\nexport function header_getStart<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(header: Header<TFeatures, TData, TValue>): number {\n  if (header.index > 0) {\n    const prevSiblingHeader = header.headerGroup?.headers[header.index - 1]\n    if (prevSiblingHeader) {\n      return (\n        callMemoOrStaticFn(prevSiblingHeader, 'getStart', header_getStart) +\n        callMemoOrStaticFn(prevSiblingHeader, 'getSize', header_getSize)\n      )\n    }\n  }\n\n  return 0\n}\n\n// Table APIs\n\n/**\n * Routes a committed column sizing updater through the table's sizing handler.\n *\n * The updater may be a next size map or a function of the previous map,\n * matching the instance `table.setColumnSizing` behavior.\n *\n * @example\n * ```ts\n * table_setColumnSizing(table, (old) => ({ ...old, age: 96 }))\n * ```\n */\nexport function table_setColumnSizing<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<ColumnSizingState>,\n) {\n  table.options.onColumnSizingChange?.(updater)\n}\n\n/**\n * Resets `columnSizing` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.columnSizing` when it\n * exists. Passing `true` ignores initial state and resets to `{}`.\n *\n * @example\n * ```ts\n * table_resetColumnSizing(table)\n * table_resetColumnSizing(table, true)\n * ```\n */\nexport function table_resetColumnSizing<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setColumnSizing(\n    table,\n    defaultState\n      ? makeObjectMap()\n      : Object.assign(\n          makeObjectMap<number>(),\n          cloneState(table.initialState.columnSizing ?? {}),\n        ),\n  )\n}\n\n/**\n * Sums the rendered size of the full table header row.\n *\n * This includes start, center, and end columns in the main header group.\n *\n * @example\n * ```ts\n * const width = table_getTotalSize(table)\n * ```\n */\nexport function table_getTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    table.getHeaderGroups()[0]?.headers.reduce((sum, header) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n\n/**\n * Sums the rendered size of the logical start pinned header region.\n *\n * An empty start pinning region returns `0`.\n *\n * @example\n * ```ts\n * const width = table_getStartTotalSize(table)\n * ```\n */\nexport function table_getStartTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    callMemoOrStaticFn(\n      table,\n      'getStartHeaderGroups',\n      table_getStartHeaderGroups,\n    )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n\n/**\n * Sums the rendered size of the center, unpinned header region.\n *\n * An empty center region returns `0`.\n *\n * @example\n * ```ts\n * const width = table_getCenterTotalSize(table)\n * ```\n */\nexport function table_getCenterTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    callMemoOrStaticFn(\n      table,\n      'getCenterHeaderGroups',\n      table_getCenterHeaderGroups,\n    )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n\n/**\n * Sums the rendered size of the logical end pinned header region.\n *\n * An empty end pinning region returns `0`.\n *\n * @example\n * ```ts\n * const width = table_getEndTotalSize(table)\n * ```\n */\nexport function table_getEndTotalSize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (\n    callMemoOrStaticFn(\n      table,\n      'getEndHeaderGroups',\n      table_getEndHeaderGroups,\n    )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {\n      return sum + header_getSize(header)\n    }, 0) ?? 0\n  )\n}\n"],"mappings":"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"}

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

@@ -1,83 +0,0 @@
-const require_utils = require('../../utils.cjs');
-const require_columnVisibilityFeature_utils = require('./columnVisibilityFeature.utils.cjs');
-
-//#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: require_columnVisibilityFeature_utils.getDefaultColumnVisibilityState(),
-			...initialState
-		};
-	},
-	getDefaultTableOptions: (table) => {
-		return { onColumnVisibilityChange: require_utils.makeStateUpdater("columnVisibility", table) };
-	},
-	assignColumnPrototype: (prototype, table) => {
-		require_utils.assignPrototypeAPIs("columnVisibilityFeature", prototype, table, {
-			column_getIsVisible: {
-				fn: (column) => require_columnVisibilityFeature_utils.column_getIsVisible(column),
-				memoDeps: (column) => [
-					table.options.columns,
-					table.atoms.columnVisibility?.get(),
-					column.columns
-				]
-			},
-			column_getCanHide: { fn: (column) => require_columnVisibilityFeature_utils.column_getCanHide(column) },
-			column_getToggleVisibilityHandler: { fn: (column) => require_columnVisibilityFeature_utils.column_getToggleVisibilityHandler(column) },
-			column_toggleVisibility: { fn: (column, visible) => require_columnVisibilityFeature_utils.column_toggleVisibility(column, visible) }
-		});
-	},
-	assignRowPrototype: (prototype, table) => {
-		require_utils.assignPrototypeAPIs("columnVisibilityFeature", prototype, table, {
-			row_getVisibleCells: {
-				fn: (row) => require_columnVisibilityFeature_utils.row_getVisibleCells(row),
-				memoDeps: (row) => [
-					row.getAllCells(),
-					table.atoms.columnPinning?.get(),
-					table.atoms.columnVisibility?.get()
-				]
-			},
-			row_getVisibleCellsByColumnId: {
-				fn: (row) => require_columnVisibilityFeature_utils.row_getVisibleCellsByColumnId(row),
-				memoDeps: (row) => [row.getAllCells(), table.atoms.columnVisibility?.get()]
-			}
-		});
-	},
-	constructTableAPIs: (table) => {
-		require_utils.assignTableAPIs("columnVisibilityFeature", table, {
-			table_getVisibleFlatColumns: {
-				fn: () => require_columnVisibilityFeature_utils.table_getVisibleFlatColumns(table),
-				memoDeps: () => [
-					table.atoms.columnVisibility?.get(),
-					table.atoms.columnOrder?.get(),
-					table.atoms.grouping?.get(),
-					table.options.columns,
-					table.options.groupedColumnMode
-				]
-			},
-			table_getVisibleLeafColumns: {
-				fn: () => require_columnVisibilityFeature_utils.table_getVisibleLeafColumns(table),
-				memoDeps: () => [
-					table.atoms.columnVisibility?.get(),
-					table.atoms.columnOrder?.get(),
-					table.atoms.grouping?.get(),
-					table.options.columns,
-					table.options.groupedColumnMode
-				]
-			},
-			table_setColumnVisibility: { fn: (updater) => require_columnVisibilityFeature_utils.table_setColumnVisibility(table, updater) },
-			table_resetColumnVisibility: { fn: (defaultState) => require_columnVisibilityFeature_utils.table_resetColumnVisibility(table, defaultState) },
-			table_toggleAllColumnsVisible: { fn: (value) => require_columnVisibilityFeature_utils.table_toggleAllColumnsVisible(table, value) },
-			table_getIsAllColumnsVisible: { fn: () => require_columnVisibilityFeature_utils.table_getIsAllColumnsVisible(table) },
-			table_getIsSomeColumnsVisible: { fn: () => require_columnVisibilityFeature_utils.table_getIsSomeColumnsVisible(table) },
-			table_getToggleAllColumnsVisibilityHandler: { fn: () => require_columnVisibilityFeature_utils.table_getToggleAllColumnsVisibilityHandler(table) }
-		});
-	}
-};
-
-//#endregion
-exports.columnVisibilityFeature = columnVisibilityFeature;
-//# sourceMappingURL=columnVisibilityFeature.cjs.map

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

@@ -1 +0,0 @@
-{"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;KACpB,MAAM,QAAQ;KACd,MAAM,MAAM,kBAAkB,IAAI;KAClC,OAAO;IACT;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;KACjB,IAAI,YAAY;KAChB,MAAM,MAAM,eAAe,IAAI;KAC/B,MAAM,MAAM,kBAAkB,IAAI;IACpC;GACF;GACA,+BAA+B;IAC7B,KAAK,QAAQC,oEAA8B,GAAG;IAC9C,WAAW,QAAQ,CACjB,IAAI,YAAY,GAChB,MAAM,MAAM,kBAAkB,IAAI,CACpC;GACF;EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,8BAAgB,2BAA2B,OAAO;GAChD,6BAA6B;IAC3B,UAAUC,kEAA4B,KAAK;IAC3C,gBAAgB;KACd,MAAM,MAAM,kBAAkB,IAAI;KAClC,MAAM,MAAM,aAAa,IAAI;KAC7B,MAAM,MAAM,UAAU,IAAI;KAC1B,MAAM,QAAQ;KACd,MAAM,QAAQ;IAChB;GACF;GACA,6BAA6B;IAC3B,UAAUC,kEAA4B,KAAK;IAC3C,gBAAgB;KACd,MAAM,MAAM,kBAAkB,IAAI;KAClC,MAAM,MAAM,aAAa,IAAI;KAC7B,MAAM,MAAM,UAAU,IAAI;KAC1B,MAAM,QAAQ;KACd,MAAM,QAAQ;IAChB;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.d.cts

@@ -1,10 +0,0 @@
-import { TableFeature } from "../../types/TableFeatures.cjs";
-
-//#region src/features/column-visibility/columnVisibilityFeature.d.ts
-/**
- * Feature that adds column visibility state and APIs for hiding and showing columns.
- */
-declare const columnVisibilityFeature: TableFeature;
-//#endregion
-export { columnVisibilityFeature };
-//# sourceMappingURL=columnVisibilityFeature.d.cts.map

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

@@ -1 +0,0 @@
-{"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;KACpB,MAAM,QAAQ;KACd,MAAM,MAAM,kBAAkB,IAAI;KAClC,OAAO;IACT;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;KACjB,IAAI,YAAY;KAChB,MAAM,MAAM,eAAe,IAAI;KAC/B,MAAM,MAAM,kBAAkB,IAAI;IACpC;GACF;GACA,+BAA+B;IAC7B,KAAK,QAAQ,8BAA8B,GAAG;IAC9C,WAAW,QAAQ,CACjB,IAAI,YAAY,GAChB,MAAM,MAAM,kBAAkB,IAAI,CACpC;GACF;EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,gBAAgB,2BAA2B,OAAO;GAChD,6BAA6B;IAC3B,UAAU,4BAA4B,KAAK;IAC3C,gBAAgB;KACd,MAAM,MAAM,kBAAkB,IAAI;KAClC,MAAM,MAAM,aAAa,IAAI;KAC7B,MAAM,MAAM,UAAU,IAAI;KAC1B,MAAM,QAAQ;KACd,MAAM,QAAQ;IAChB;GACF;GACA,6BAA6B;IAC3B,UAAU,4BAA4B,KAAK;IAC3C,gBAAgB;KACd,MAAM,MAAM,kBAAkB,IAAI;KAClC,MAAM,MAAM,aAAa,IAAI;KAC7B,MAAM,MAAM,UAAU,IAAI;KAC1B,MAAM,QAAQ;KACd,MAAM,QAAQ;IAChB;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

@@ -1,97 +0,0 @@
-import { OnChangeFn, RowData, Updater } from "../../types/type-utils.cjs";
-import { Cell } from "../../types/Cell.cjs";
-import { Column } from "../../types/Column.cjs";
-import { TableFeatures } from "../../types/TableFeatures.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<in out TFeatures extends TableFeatures, in out 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<in out TFeatures extends TableFeatures, in out 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.utils.cjs

@@ -1,284 +0,0 @@
-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 require_utils.makeObjectMap();
-}
-/**
-* 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 start unchanged.
-*
-* @example
-* ```ts
-* column_toggleVisibility(column)
-* ```
-*/
-function column_toggleVisibility(column, visible) {
-	if (column_getCanHide(column)) table_setColumnVisibility(column.table, (old) => {
-		const next = Object.assign(require_utils.makeObjectMap(), old);
-		next[column.id] = visible ?? !require_utils.callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible);
-		return next;
-	});
-}
-/**
-* 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) {
-	const columnVisibility = column.table.atoms.columnVisibility?.get();
-	if (!columnVisibility) return true;
-	const childColumns = column.columns;
-	if (childColumns.length) return childColumns.some((childColumn) => require_utils.callMemoOrStaticFn(childColumn, "getIsVisible", column_getIsVisible));
-	return (require_utils.hasOwn(columnVisibility, column.id) ? columnVisibility[column.id] : void 0) ?? 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 start-pinned cells,
-* center cells, then end-pinned cells.
-*
-* @example
-* ```ts
-* const visibleCells = row_getVisibleCells(row)
-* ```
-*/
-function row_getVisibleCells(row) {
-	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 { start, end } = row.table.atoms.columnPinning?.get() ?? require_columnPinningFeature_utils.getDefaultColumnPinningState();
-	if (!start.length && !end.length) return visibleCells;
-	const visibleCellsByColumnId = require_utils.callMemoOrStaticFn(row, "getVisibleCellsByColumnId", row_getVisibleCellsByColumnId);
-	const startCells = [];
-	for (let i = 0; i < start.length; i++) {
-		const cell = visibleCellsByColumnId[start[i]];
-		if (cell) startCells.push(cell);
-	}
-	const endCells = [];
-	for (let i = 0; i < end.length; i++) {
-		const cell = visibleCellsByColumnId[end[i]];
-		if (cell) endCells.push(cell);
-	}
-	const centerCells = [];
-	for (let i = 0; i < visibleCells.length; i++) {
-		const cell = visibleCells[i];
-		const id = cell.column.id;
-		if (!start.includes(id) && !end.includes(id)) centerCells.push(cell);
-	}
-	return [
-		...startCells,
-		...centerCells,
-		...endCells
-	];
-}
-/**
-* 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 = require_utils.makeObjectMap();
-	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) {
-	table.options.onColumnVisibilityChange?.(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.makeObjectMap() : Object.assign(require_utils.makeObjectMap(), 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 = require_utils.makeObjectMap();
-	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

@@ -1 +0,0 @@
-{"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 start 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 start-pinned cells,\n * center cells, then end-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 { start, end } =\n    row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()\n  if (!start.length && !end.length) return visibleCells // no pinning, return early\n\n  const visibleCellsByColumnId = callMemoOrStaticFn(\n    row,\n    'getVisibleCellsByColumnId',\n    row_getVisibleCellsByColumnId,\n  )\n\n  const startCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < start.length; i++) {\n    const cell = visibleCellsByColumnId[start[i]!]\n    if (cell) startCells.push(cell)\n  }\n\n  const endCells: Array<Cell<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < end.length; i++) {\n    const cell = visibleCellsByColumnId[end[i]!]\n    if (cell) endCells.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 (!start.includes(id) && !end.includes(id)) centerCells.push(cell)\n  }\n\n  return [...startCells, ...centerCells, ...endCells]\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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"}