@tanstack/table-core 9.0.0-beta.9 → 9.0.1

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

@@ -1,189 +0,0 @@
-import { CellData, RowData, Updater } from "../../types/type-utils.cjs";
-import { Column, Column_Internal } from "../../types/Column.cjs";
-import { ColumnVisibilityState } from "./columnVisibilityFeature.types.cjs";
-import { Row } from "../../types/Row.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-import { Table_Internal } from "../../types/Table.cjs";
-import { Cell } from "../../types/Cell.cjs";
-//#region src/features/column-visibility/columnVisibilityFeature.utils.d.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()
- * ```
- */
-declare function getDefaultColumnVisibilityState(): ColumnVisibilityState;
-/**
- * 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)
- * ```
- */
-declare function column_toggleVisibility<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>, visible?: boolean): void;
-/**
- * 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)
- * ```
- */
-declare function column_getIsVisible<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
-/**
- * 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)
- * ```
- */
-declare function column_getCanHide<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
-/**
- * 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)
- * ```
- */
-declare function column_getToggleVisibilityHandler<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): (e: unknown) => void;
-/**
- * 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)
- * ```
- */
-declare function row_getVisibleCells<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>>;
-/**
- * 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)
- * ```
- */
-declare function row_getVisibleCellsByColumnId<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): Record<string, Cell<TFeatures, TData, unknown>>;
-/**
- * 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)
- * ```
- */
-declare function table_getVisibleFlatColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Column<TFeatures, TData, unknown>[];
-/**
- * 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)
- * ```
- */
-declare function table_getVisibleLeafColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Column<TFeatures, TData, unknown>[];
-/**
- * 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 }))
- * ```
- */
-declare function table_setColumnVisibility<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<ColumnVisibilityState>): void;
-/**
- * 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)
- * ```
- */
-declare function table_resetColumnVisibility<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
-/**
- * Shows or hides every hideable leaf column.
- *
- * Columns that cannot hide stay visible when toggling all columns off.
- *
- * @example
- * ```ts
- * table_toggleAllColumnsVisible(table)
- * ```
- */
-declare function table_toggleAllColumnsVisible<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, value?: boolean): void;
-/**
- * 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)
- * ```
- */
-declare function table_getIsAllColumnsVisible<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
-/**
- * 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)
- * ```
- */
-declare function table_getIsSomeColumnsVisible<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
-/**
- * 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)
- * ```
- */
-declare function table_getToggleAllColumnsVisibilityHandler<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): (e: unknown) => void;
-//#endregion
-export { 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 };
-//# sourceMappingURL=columnVisibilityFeature.utils.d.cts.map

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

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

package/dist/features/global-filtering/globalFilteringFeature.cjs

@@ -1,41 +0,0 @@
-const require_utils = require('../../utils.cjs');
-const require_globalFilteringFeature_utils = require('./globalFilteringFeature.utils.cjs');
-
-//#region src/features/global-filtering/globalFilteringFeature.ts
-/**
-* Feature that adds global filtering state, defaults, and global filter APIs.
-*/
-const globalFilteringFeature = {
-	getInitialState: (initialState) => {
-		return {
-			globalFilter: void 0,
-			...initialState
-		};
-	},
-	getDefaultTableOptions: (table) => {
-		return {
-			onGlobalFilterChange: require_utils.makeStateUpdater("globalFilter", table),
-			globalFilterFn: "auto",
-			getColumnCanGlobalFilter: (column) => {
-				var _table$getCoreRowMode;
-				const value = (_table$getCoreRowMode = table.getCoreRowModel().flatRows[0]) === null || _table$getCoreRowMode === void 0 || (_table$getCoreRowMode = _table$getCoreRowMode.getAllCellsByColumnId()[column.id]) === null || _table$getCoreRowMode === void 0 ? void 0 : _table$getCoreRowMode.getValue();
-				return typeof value === "string" || typeof value === "number";
-			}
-		};
-	},
-	assignColumnPrototype: (prototype, table) => {
-		require_utils.assignPrototypeAPIs("globalFilteringFeature", prototype, table, { column_getCanGlobalFilter: { fn: (column) => require_globalFilteringFeature_utils.column_getCanGlobalFilter(column) } });
-	},
-	constructTableAPIs: (table) => {
-		require_utils.assignTableAPIs("globalFilteringFeature", table, {
-			table_getGlobalAutoFilterFn: { fn: () => require_globalFilteringFeature_utils.table_getGlobalAutoFilterFn() },
-			table_getGlobalFilterFn: { fn: () => require_globalFilteringFeature_utils.table_getGlobalFilterFn(table) },
-			table_setGlobalFilter: { fn: (updater) => require_globalFilteringFeature_utils.table_setGlobalFilter(table, updater) },
-			table_resetGlobalFilter: { fn: (defaultState) => require_globalFilteringFeature_utils.table_resetGlobalFilter(table, defaultState) }
-		});
-	}
-};
-
-//#endregion
-exports.globalFilteringFeature = globalFilteringFeature;
-//# sourceMappingURL=globalFilteringFeature.cjs.map

package/dist/features/global-filtering/globalFilteringFeature.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"globalFilteringFeature.cjs","names":["makeStateUpdater","column_getCanGlobalFilter","table_getGlobalAutoFilterFn","table_getGlobalFilterFn","table_setGlobalFilter","table_resetGlobalFilter"],"sources":["../../../src/features/global-filtering/globalFilteringFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  column_getCanGlobalFilter,\n  table_getGlobalAutoFilterFn,\n  table_getGlobalFilterFn,\n  table_resetGlobalFilter,\n  table_setGlobalFilter,\n} from './globalFilteringFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Feature that adds global filtering state, defaults, and global filter APIs.\n */\nexport const globalFilteringFeature: TableFeature = {\n  getInitialState: (initialState) => {\n    return {\n      globalFilter: undefined,\n      ...initialState,\n    }\n  },\n\n  getDefaultTableOptions: (table) => {\n    return {\n      onGlobalFilterChange: makeStateUpdater('globalFilter', table),\n      globalFilterFn: 'auto',\n      getColumnCanGlobalFilter: (column) => {\n        const value = table\n          .getCoreRowModel()\n          .flatRows[0]?.getAllCellsByColumnId()\n          [column.id]?.getValue()\n\n        return typeof value === 'string' || typeof value === 'number'\n      },\n    }\n  },\n\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('globalFilteringFeature', prototype, table, {\n      column_getCanGlobalFilter: {\n        fn: (column) => column_getCanGlobalFilter(column),\n      },\n    })\n  },\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('globalFilteringFeature', table, {\n      table_getGlobalAutoFilterFn: {\n        fn: () => table_getGlobalAutoFilterFn(),\n      },\n      table_getGlobalFilterFn: {\n        fn: () => table_getGlobalFilterFn(table),\n      },\n      table_setGlobalFilter: {\n        fn: (updater) => table_setGlobalFilter(table, updater),\n      },\n      table_resetGlobalFilter: {\n        fn: (defaultState) => table_resetGlobalFilter(table, defaultState),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AAiBA,MAAa,yBAAuC;CAClD,kBAAkB,iBAAiB;EACjC,OAAO;GACL,cAAc;GACd,GAAG;EACL;CACF;CAEA,yBAAyB,UAAU;EACjC,OAAO;GACL,sBAAsBA,+BAAiB,gBAAgB,KAAK;GAC5D,gBAAgB;GAChB,2BAA2B,WAAW;;IACpC,MAAM,iCAAQ,MACX,gBAAgB,CAAC,CACjB,SAAS,mGAAI,sBAAsB,CAAC,CACpC,OAAO,mFAAK,SAAS;IAExB,OAAO,OAAO,UAAU,YAAY,OAAO,UAAU;GACvD;EACF;CACF;CAEA,wBAAwB,WAAW,UAAU;EAC3C,kCAAoB,0BAA0B,WAAW,OAAO,EAC9D,2BAA2B,EACzB,KAAK,WAAWC,+DAA0B,MAAM,EAClD,EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,8BAAgB,0BAA0B,OAAO;GAC/C,6BAA6B,EAC3B,UAAUC,iEAA4B,EACxC;GACA,yBAAyB,EACvB,UAAUC,6DAAwB,KAAK,EACzC;GACA,uBAAuB,EACrB,KAAK,YAAYC,2DAAsB,OAAO,OAAO,EACvD;GACA,yBAAyB,EACvB,KAAK,iBAAiBC,6DAAwB,OAAO,YAAY,EACnE;EACF,CAAC;CACH;AACF"}

package/dist/features/global-filtering/globalFilteringFeature.d.cts

@@ -1,10 +0,0 @@
-import { TableFeature } from "../../types/TableFeatures.cjs";
-
-//#region src/features/global-filtering/globalFilteringFeature.d.ts
-/**
- * Feature that adds global filtering state, defaults, and global filter APIs.
- */
-declare const globalFilteringFeature: TableFeature;
-//#endregion
-export { globalFilteringFeature };
-//# sourceMappingURL=globalFilteringFeature.d.cts.map

package/dist/features/global-filtering/globalFilteringFeature.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"globalFilteringFeature.js","names":[],"sources":["../../../src/features/global-filtering/globalFilteringFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  column_getCanGlobalFilter,\n  table_getGlobalAutoFilterFn,\n  table_getGlobalFilterFn,\n  table_resetGlobalFilter,\n  table_setGlobalFilter,\n} from './globalFilteringFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Feature that adds global filtering state, defaults, and global filter APIs.\n */\nexport const globalFilteringFeature: TableFeature = {\n  getInitialState: (initialState) => {\n    return {\n      globalFilter: undefined,\n      ...initialState,\n    }\n  },\n\n  getDefaultTableOptions: (table) => {\n    return {\n      onGlobalFilterChange: makeStateUpdater('globalFilter', table),\n      globalFilterFn: 'auto',\n      getColumnCanGlobalFilter: (column) => {\n        const value = table\n          .getCoreRowModel()\n          .flatRows[0]?.getAllCellsByColumnId()\n          [column.id]?.getValue()\n\n        return typeof value === 'string' || typeof value === 'number'\n      },\n    }\n  },\n\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('globalFilteringFeature', prototype, table, {\n      column_getCanGlobalFilter: {\n        fn: (column) => column_getCanGlobalFilter(column),\n      },\n    })\n  },\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('globalFilteringFeature', table, {\n      table_getGlobalAutoFilterFn: {\n        fn: () => table_getGlobalAutoFilterFn(),\n      },\n      table_getGlobalFilterFn: {\n        fn: () => table_getGlobalFilterFn(table),\n      },\n      table_setGlobalFilter: {\n        fn: (updater) => table_setGlobalFilter(table, updater),\n      },\n      table_resetGlobalFilter: {\n        fn: (defaultState) => table_resetGlobalFilter(table, defaultState),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AAiBA,MAAa,yBAAuC;CAClD,kBAAkB,iBAAiB;EACjC,OAAO;GACL,cAAc;GACd,GAAG;EACL;CACF;CAEA,yBAAyB,UAAU;EACjC,OAAO;GACL,sBAAsB,iBAAiB,gBAAgB,KAAK;GAC5D,gBAAgB;GAChB,2BAA2B,WAAW;;IACpC,MAAM,iCAAQ,MACX,gBAAgB,CAAC,CACjB,SAAS,mGAAI,sBAAsB,CAAC,CACpC,OAAO,mFAAK,SAAS;IAExB,OAAO,OAAO,UAAU,YAAY,OAAO,UAAU;GACvD;EACF;CACF;CAEA,wBAAwB,WAAW,UAAU;EAC3C,oBAAoB,0BAA0B,WAAW,OAAO,EAC9D,2BAA2B,EACzB,KAAK,WAAW,0BAA0B,MAAM,EAClD,EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,gBAAgB,0BAA0B,OAAO;GAC/C,6BAA6B,EAC3B,UAAU,4BAA4B,EACxC;GACA,yBAAyB,EACvB,UAAU,wBAAwB,KAAK,EACzC;GACA,uBAAuB,EACrB,KAAK,YAAY,sBAAsB,OAAO,OAAO,EACvD;GACA,yBAAyB,EACvB,KAAK,iBAAiB,wBAAwB,OAAO,YAAY,EACnE;EACF,CAAC;CACH;AACF"}

package/dist/features/global-filtering/globalFilteringFeature.types.d.cts

@@ -1,71 +0,0 @@
-import { CellData, OnChangeFn, RowData, Updater } from "../../types/type-utils.cjs";
-import { FilterFn, FilterFnOption } from "../column-filtering/columnFilteringFeature.types.cjs";
-import { Column } from "../../types/Column.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-
-//#region src/features/global-filtering/globalFilteringFeature.types.d.ts
-interface TableState_GlobalFiltering {
-  globalFilter: any;
-}
-interface ColumnDef_GlobalFiltering {
-  /**
-   * Allows this column to be scanned by global filtering.
-   *
-   * Defaults to `true`; table-level global filtering and `enableFilters` must
-   * also allow filtering.
-   */
-  enableGlobalFilter?: boolean;
-}
-interface Column_GlobalFiltering {
-  /**
-   * Checks whether this accessor column participates in global filtering.
-   */
-  getCanGlobalFilter: () => boolean;
-}
-interface TableOptions_GlobalFiltering<TFeatures extends TableFeatures, TData extends RowData> {
-  /**
-   * Enables global filtering across columns that allow it.
-   */
-  enableGlobalFilter?: boolean;
-  /**
-   * If provided, this function will be called with the column and should return `true` or `false` to indicate whether this column should be used for global filtering.
-   * This is useful if the column can contain data that is not `string` or `number` (i.e. `undefined`).
-   */
-  getColumnCanGlobalFilter?: <TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>) => boolean;
-  /**
-   * The filter function to use for global filtering.
-   * - A `string` referencing a built-in filter function
-   * - A `string` that references a custom filter functions provided via the `tableOptions.filterFns` option
-   * - A custom filter function
-   */
-  globalFilterFn?: FilterFnOption<TFeatures, TData>;
-  /**
-   * Called with an updater when global filter state changes. Pair this with
-   * `state.globalFilter` when using external state; external atoms can own the
-   * slice without this callback.
-   */
-  onGlobalFilterChange?: OnChangeFn<any>;
-}
-interface Table_GlobalFiltering<TFeatures extends TableFeatures, TData extends RowData> {
-  /**
-   * Currently, this function returns the built-in `includesString` filter function. In future releases, it may return more dynamic filter functions based on the nature of the data provided.
-   */
-  getGlobalAutoFilterFn: () => FilterFn<TFeatures, TData> | undefined;
-  /**
-   * Returns the filter function (either user-defined or automatic, depending on configuration) for the global filter.
-   */
-  getGlobalFilterFn: () => FilterFn<TFeatures, TData> | undefined;
-  /**
-   * Resets `globalFilter` to `initialState.globalFilter`.
-   *
-   * Pass `true` to ignore initial state and reset to `undefined`.
-   */
-  resetGlobalFilter: (defaultState?: boolean) => void;
-  /**
-   * Updates global filter state with a next value or updater function.
-   */
-  setGlobalFilter: (updater: Updater<any>) => void;
-}
-//#endregion
-export { ColumnDef_GlobalFiltering, Column_GlobalFiltering, TableOptions_GlobalFiltering, TableState_GlobalFiltering, Table_GlobalFiltering };
-//# sourceMappingURL=globalFilteringFeature.types.d.cts.map

package/dist/features/global-filtering/globalFilteringFeature.utils.cjs

@@ -1,88 +0,0 @@
-const require_utils = require('../../utils.cjs');
-const require_filterFns = require('../../fns/filterFns.cjs');
-
-//#region src/features/global-filtering/globalFilteringFeature.utils.ts
-/**
-* Checks whether this accessor column participates in global filtering.
-*
-* The column must have an accessor and pass column-level, table-level, and
-* optional `getColumnCanGlobalFilter` checks.
-*
-* @example
-* ```ts
-* const canGlobalFilter = column_getCanGlobalFilter(column)
-* ```
-*/
-function column_getCanGlobalFilter(column) {
-	var _column$table$options, _column$table$options2;
-	return (column.columnDef.enableGlobalFilter ?? true) && (column.table.options.enableGlobalFilter ?? true) && (column.table.options.enableFilters ?? true) && (((_column$table$options = (_column$table$options2 = column.table.options).getColumnCanGlobalFilter) === null || _column$table$options === void 0 ? void 0 : _column$table$options.call(_column$table$options2, column)) ?? true) && !!column.accessorFn;
-}
-/**
-* Provides the built-in automatic global filter function.
-*
-* Global filtering defaults to `includesString`, which gives search-box style
-* matching across globally filterable columns.
-*
-* @example
-* ```ts
-* const filterFn = table_getGlobalAutoFilterFn()
-* ```
-*/
-function table_getGlobalAutoFilterFn() {
-	return require_filterFns.filterFn_includesString;
-}
-/**
-* Resolves the filter function used for global filtering.
-*
-* Function-valued `options.globalFilterFn` is returned directly, `'auto'`
-* delegates to `table_getGlobalAutoFilterFn`, and string values are looked up in
-* the table's filter function registry.
-*
-* @example
-* ```ts
-* const filterFn = table_getGlobalFilterFn(table)
-* ```
-*/
-function table_getGlobalFilterFn(table) {
-	const { globalFilterFn } = table.options;
-	const filterFns = table._rowModelFns.filterFns;
-	return require_utils.isFunction(globalFilterFn) ? globalFilterFn : globalFilterFn === "auto" ? table_getGlobalAutoFilterFn() : filterFns === null || filterFns === void 0 ? void 0 : filterFns[globalFilterFn];
-}
-/**
-* Routes a global filter updater through the table's global filter handler.
-*
-* The updater may be a next value or a function of the previous value, matching
-* the instance `table.setGlobalFilter` behavior.
-*
-* @example
-* ```ts
-* table_setGlobalFilter(table, 'search text')
-* ```
-*/
-function table_setGlobalFilter(table, updater) {
-	var _table$options$onGlob, _table$options;
-	(_table$options$onGlob = (_table$options = table.options).onGlobalFilterChange) === null || _table$options$onGlob === void 0 || _table$options$onGlob.call(_table$options, updater);
-}
-/**
-* Resets `globalFilter` to the configured initial state or feature default.
-*
-* With no argument, the reset clones `table.initialState.globalFilter`. Passing
-* `true` ignores initial state and resets to `undefined`.
-*
-* @example
-* ```ts
-* table_resetGlobalFilter(table)
-* table_resetGlobalFilter(table, true)
-* ```
-*/
-function table_resetGlobalFilter(table, defaultState) {
-	table_setGlobalFilter(table, defaultState ? void 0 : require_utils.cloneState(table.initialState.globalFilter));
-}
-
-//#endregion
-exports.column_getCanGlobalFilter = column_getCanGlobalFilter;
-exports.table_getGlobalAutoFilterFn = table_getGlobalAutoFilterFn;
-exports.table_getGlobalFilterFn = table_getGlobalFilterFn;
-exports.table_resetGlobalFilter = table_resetGlobalFilter;
-exports.table_setGlobalFilter = table_setGlobalFilter;
-//# sourceMappingURL=globalFilteringFeature.utils.cjs.map

package/dist/features/global-filtering/globalFilteringFeature.utils.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"globalFilteringFeature.utils.cjs","names":["filterFn_includesString","isFunction","cloneState"],"sources":["../../../src/features/global-filtering/globalFilteringFeature.utils.ts"],"sourcesContent":["import { filterFn_includesString } from '../../fns/filterFns'\nimport { cloneState, isFunction } from '../../utils'\nimport type { Column_Internal } from '../../types/Column'\nimport type { FilterFn } from '../column-filtering/columnFilteringFeature.types'\nimport type { CellData, RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\n\n/**\n * Checks whether this accessor column participates in global filtering.\n *\n * The column must have an accessor and pass column-level, table-level, and\n * optional `getColumnCanGlobalFilter` checks.\n *\n * @example\n * ```ts\n * const canGlobalFilter = column_getCanGlobalFilter(column)\n * ```\n */\nexport function column_getCanGlobalFilter<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): boolean {\n  return (\n    (column.columnDef.enableGlobalFilter ?? true) &&\n    (column.table.options.enableGlobalFilter ?? true) &&\n    (column.table.options.enableFilters ?? true) &&\n    (column.table.options.getColumnCanGlobalFilter?.(column) ?? true) &&\n    !!column.accessorFn\n  )\n}\n\n/**\n * Provides the built-in automatic global filter function.\n *\n * Global filtering defaults to `includesString`, which gives search-box style\n * matching across globally filterable columns.\n *\n * @example\n * ```ts\n * const filterFn = table_getGlobalAutoFilterFn()\n * ```\n */\nexport function table_getGlobalAutoFilterFn() {\n  return filterFn_includesString\n}\n\n/**\n * Resolves the filter function used for global filtering.\n *\n * Function-valued `options.globalFilterFn` is returned directly, `'auto'`\n * delegates to `table_getGlobalAutoFilterFn`, and string values are looked up in\n * the table's filter function registry.\n *\n * @example\n * ```ts\n * const filterFn = table_getGlobalFilterFn(table)\n * ```\n */\nexport function table_getGlobalFilterFn<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n): FilterFn<TFeatures, TData> | FilterFn<TFeatures, TData> | undefined {\n  const { globalFilterFn: globalFilterFn } = table.options\n  const filterFns: Record<string, FilterFn<TFeatures, RowData>> | undefined =\n    table._rowModelFns.filterFns\n\n  const filterFn = isFunction(globalFilterFn)\n    ? globalFilterFn\n    : globalFilterFn === 'auto'\n      ? table_getGlobalAutoFilterFn()\n      : filterFns?.[globalFilterFn as string]\n\n  return filterFn as FilterFn<TFeatures, TData> | undefined\n}\n\n/**\n * Routes a global filter updater through the table's global filter handler.\n *\n * The updater may be a next value or a function of the previous value, matching\n * the instance `table.setGlobalFilter` behavior.\n *\n * @example\n * ```ts\n * table_setGlobalFilter(table, 'search text')\n * ```\n */\nexport function table_setGlobalFilter<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: any) {\n  table.options.onGlobalFilterChange?.(updater)\n}\n\n/**\n * Resets `globalFilter` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.globalFilter`. Passing\n * `true` ignores initial state and resets to `undefined`.\n *\n * @example\n * ```ts\n * table_resetGlobalFilter(table)\n * table_resetGlobalFilter(table, true)\n * ```\n */\nexport function table_resetGlobalFilter<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setGlobalFilter(\n    table,\n    defaultState ? undefined : cloneState(table.initialState.globalFilter),\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,0BAId,QAA4D;;CAC5D,QACG,OAAO,UAAU,sBAAsB,UACvC,OAAO,MAAM,QAAQ,sBAAsB,UAC3C,OAAO,MAAM,QAAQ,iBAAiB,8DACtC,OAAO,MAAM,SAAQ,qIAA2B,MAAM,MAAK,SAC5D,CAAC,CAAC,OAAO;AAEb;;;;;;;;;;;;AAaA,SAAgB,8BAA8B;CAC5C,OAAOA;AACT;;;;;;;;;;;;;AAcA,SAAgB,wBAId,OACqE;CACrE,MAAM,EAAkB,mBAAmB,MAAM;CACjD,MAAM,YACJ,MAAM,aAAa;CAQrB,OANiBC,yBAAW,cAAc,IACtC,iBACA,mBAAmB,SACjB,4BAA4B,0DAC5B,UAAY;AAGpB;;;;;;;;;;;;AAaA,SAAgB,sBAGd,OAAyC,SAAc;;CACvD,iDAAM,SAAQ,iHAAuB,OAAO;AAC9C;;;;;;;;;;;;;AAcA,SAAgB,wBAGd,OAAyC,cAAwB;CACjE,sBACE,OACA,eAAe,SAAYC,yBAAW,MAAM,aAAa,YAAY,CACvE;AACF"}

package/dist/features/global-filtering/globalFilteringFeature.utils.d.cts

@@ -1,74 +0,0 @@
-import { CellData, RowData } from "../../types/type-utils.cjs";
-import { FilterFn } from "../column-filtering/columnFilteringFeature.types.cjs";
-import { Column_Internal } from "../../types/Column.cjs";
-import { Row } from "../../types/Row.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-import { Table_Internal } from "../../types/Table.cjs";
-//#region src/features/global-filtering/globalFilteringFeature.utils.d.ts
-/**
- * Checks whether this accessor column participates in global filtering.
- *
- * The column must have an accessor and pass column-level, table-level, and
- * optional `getColumnCanGlobalFilter` checks.
- *
- * @example
- * ```ts
- * const canGlobalFilter = column_getCanGlobalFilter(column)
- * ```
- */
-declare function column_getCanGlobalFilter<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
-/**
- * Provides the built-in automatic global filter function.
- *
- * Global filtering defaults to `includesString`, which gives search-box style
- * matching across globally filterable columns.
- *
- * @example
- * ```ts
- * const filterFn = table_getGlobalAutoFilterFn()
- * ```
- */
-declare function table_getGlobalAutoFilterFn(): (<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-  autoRemove: (val: any) => boolean;
-};
-/**
- * Resolves the filter function used for global filtering.
- *
- * Function-valued `options.globalFilterFn` is returned directly, `'auto'`
- * delegates to `table_getGlobalAutoFilterFn`, and string values are looked up in
- * the table's filter function registry.
- *
- * @example
- * ```ts
- * const filterFn = table_getGlobalFilterFn(table)
- * ```
- */
-declare function table_getGlobalFilterFn<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): FilterFn<TFeatures, TData> | FilterFn<TFeatures, TData> | undefined;
-/**
- * Routes a global filter updater through the table's global filter handler.
- *
- * The updater may be a next value or a function of the previous value, matching
- * the instance `table.setGlobalFilter` behavior.
- *
- * @example
- * ```ts
- * table_setGlobalFilter(table, 'search text')
- * ```
- */
-declare function table_setGlobalFilter<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: any): void;
-/**
- * Resets `globalFilter` to the configured initial state or feature default.
- *
- * With no argument, the reset clones `table.initialState.globalFilter`. Passing
- * `true` ignores initial state and resets to `undefined`.
- *
- * @example
- * ```ts
- * table_resetGlobalFilter(table)
- * table_resetGlobalFilter(table, true)
- * ```
- */
-declare function table_resetGlobalFilter<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
-//#endregion
-export { column_getCanGlobalFilter, table_getGlobalAutoFilterFn, table_getGlobalFilterFn, table_resetGlobalFilter, table_setGlobalFilter };
-//# sourceMappingURL=globalFilteringFeature.utils.d.cts.map

package/dist/features/global-filtering/globalFilteringFeature.utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"globalFilteringFeature.utils.js","names":[],"sources":["../../../src/features/global-filtering/globalFilteringFeature.utils.ts"],"sourcesContent":["import { filterFn_includesString } from '../../fns/filterFns'\nimport { cloneState, isFunction } from '../../utils'\nimport type { Column_Internal } from '../../types/Column'\nimport type { FilterFn } from '../column-filtering/columnFilteringFeature.types'\nimport type { CellData, RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\n\n/**\n * Checks whether this accessor column participates in global filtering.\n *\n * The column must have an accessor and pass column-level, table-level, and\n * optional `getColumnCanGlobalFilter` checks.\n *\n * @example\n * ```ts\n * const canGlobalFilter = column_getCanGlobalFilter(column)\n * ```\n */\nexport function column_getCanGlobalFilter<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): boolean {\n  return (\n    (column.columnDef.enableGlobalFilter ?? true) &&\n    (column.table.options.enableGlobalFilter ?? true) &&\n    (column.table.options.enableFilters ?? true) &&\n    (column.table.options.getColumnCanGlobalFilter?.(column) ?? true) &&\n    !!column.accessorFn\n  )\n}\n\n/**\n * Provides the built-in automatic global filter function.\n *\n * Global filtering defaults to `includesString`, which gives search-box style\n * matching across globally filterable columns.\n *\n * @example\n * ```ts\n * const filterFn = table_getGlobalAutoFilterFn()\n * ```\n */\nexport function table_getGlobalAutoFilterFn() {\n  return filterFn_includesString\n}\n\n/**\n * Resolves the filter function used for global filtering.\n *\n * Function-valued `options.globalFilterFn` is returned directly, `'auto'`\n * delegates to `table_getGlobalAutoFilterFn`, and string values are looked up in\n * the table's filter function registry.\n *\n * @example\n * ```ts\n * const filterFn = table_getGlobalFilterFn(table)\n * ```\n */\nexport function table_getGlobalFilterFn<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n): FilterFn<TFeatures, TData> | FilterFn<TFeatures, TData> | undefined {\n  const { globalFilterFn: globalFilterFn } = table.options\n  const filterFns: Record<string, FilterFn<TFeatures, RowData>> | undefined =\n    table._rowModelFns.filterFns\n\n  const filterFn = isFunction(globalFilterFn)\n    ? globalFilterFn\n    : globalFilterFn === 'auto'\n      ? table_getGlobalAutoFilterFn()\n      : filterFns?.[globalFilterFn as string]\n\n  return filterFn as FilterFn<TFeatures, TData> | undefined\n}\n\n/**\n * Routes a global filter updater through the table's global filter handler.\n *\n * The updater may be a next value or a function of the previous value, matching\n * the instance `table.setGlobalFilter` behavior.\n *\n * @example\n * ```ts\n * table_setGlobalFilter(table, 'search text')\n * ```\n */\nexport function table_setGlobalFilter<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: any) {\n  table.options.onGlobalFilterChange?.(updater)\n}\n\n/**\n * Resets `globalFilter` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.globalFilter`. Passing\n * `true` ignores initial state and resets to `undefined`.\n *\n * @example\n * ```ts\n * table_resetGlobalFilter(table)\n * table_resetGlobalFilter(table, true)\n * ```\n */\nexport function table_resetGlobalFilter<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setGlobalFilter(\n    table,\n    defaultState ? undefined : cloneState(table.initialState.globalFilter),\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,0BAId,QAA4D;;CAC5D,QACG,OAAO,UAAU,sBAAsB,UACvC,OAAO,MAAM,QAAQ,sBAAsB,UAC3C,OAAO,MAAM,QAAQ,iBAAiB,8DACtC,OAAO,MAAM,SAAQ,qIAA2B,MAAM,MAAK,SAC5D,CAAC,CAAC,OAAO;AAEb;;;;;;;;;;;;AAaA,SAAgB,8BAA8B;CAC5C,OAAO;AACT;;;;;;;;;;;;;AAcA,SAAgB,wBAId,OACqE;CACrE,MAAM,EAAkB,mBAAmB,MAAM;CACjD,MAAM,YACJ,MAAM,aAAa;CAQrB,OANiB,WAAW,cAAc,IACtC,iBACA,mBAAmB,SACjB,4BAA4B,0DAC5B,UAAY;AAGpB;;;;;;;;;;;;AAaA,SAAgB,sBAGd,OAAyC,SAAc;;CACvD,iDAAM,SAAQ,iHAAuB,OAAO;AAC9C;;;;;;;;;;;;;AAcA,SAAgB,wBAGd,OAAyC,cAAwB;CACjE,sBACE,OACA,eAAe,SAAY,WAAW,MAAM,aAAa,YAAY,CACvE;AACF"}

package/dist/features/row-expanding/createExpandedRowModel.cjs

@@ -1,59 +0,0 @@
-const require_utils = require('../../utils.cjs');
-const require_rowExpandingFeature_utils = require('./rowExpandingFeature.utils.cjs');
-
-//#region src/features/row-expanding/createExpandedRowModel.ts
-/**
-* Creates a memoized expanded row model factory.
-*
-* The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
-*/
-function createExpandedRowModel() {
-	return (_table) => {
-		const table = _table;
-		return require_utils.tableMemo({
-			feature: "rowExpandingFeature",
-			table,
-			fnName: "table.getExpandedRowModel",
-			memoDeps: () => {
-				var _table$atoms$expanded;
-				return [
-					(_table$atoms$expanded = table.atoms.expanded) === null || _table$atoms$expanded === void 0 ? void 0 : _table$atoms$expanded.get(),
-					table.getPreExpandedRowModel(),
-					table.options.paginateExpandedRows
-				];
-			},
-			fn: () => _createExpandedRowModel(table)
-		});
-	};
-}
-function _createExpandedRowModel(table) {
-	var _table$atoms$expanded2;
-	const rowModel = table.getPreExpandedRowModel();
-	const expanded = (_table$atoms$expanded2 = table.atoms.expanded) === null || _table$atoms$expanded2 === void 0 ? void 0 : _table$atoms$expanded2.get();
-	if (!rowModel.rows.length || expanded !== true && !Object.keys(expanded ?? {}).length) return rowModel;
-	if (!table.options.paginateExpandedRows) return rowModel;
-	return expandRows(rowModel);
-}
-/**
-* Expands a row model according to the current expanded row state.
-*
-* Expanded sub-rows are inserted into the flattened row order while preserving the original row hierarchy.
-*/
-function expandRows(rowModel) {
-	const expandedRows = [];
-	const handleRow = (row) => {
-		expandedRows.push(row);
-		if (row.subRows.length && require_rowExpandingFeature_utils.row_getIsExpanded(row)) row.subRows.forEach(handleRow);
-	};
-	rowModel.rows.forEach(handleRow);
-	return {
-		rows: expandedRows,
-		flatRows: rowModel.flatRows,
-		rowsById: rowModel.rowsById
-	};
-}
-
-//#endregion
-exports.createExpandedRowModel = createExpandedRowModel;
-exports.expandRows = expandRows;
-//# sourceMappingURL=createExpandedRowModel.cjs.map

package/dist/features/row-expanding/createExpandedRowModel.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createExpandedRowModel.cjs","names":["tableMemo","row_getIsExpanded"],"sources":["../../../src/features/row-expanding/createExpandedRowModel.ts"],"sourcesContent":["import { tableMemo } from '../../utils'\nimport { row_getIsExpanded } from './rowExpandingFeature.utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { Row } from '../../types/Row'\nimport type { RowData } from '../../types/type-utils'\n\n/**\n * Creates a memoized expanded row model factory.\n *\n * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.\n */\nexport function createExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {\n  return (_table) => {\n    const table = _table as unknown as Table_Internal<TFeatures, TData>\n    return tableMemo({\n      feature: 'rowExpandingFeature',\n      table,\n      fnName: 'table.getExpandedRowModel',\n      memoDeps: () => [\n        table.atoms.expanded?.get(),\n        table.getPreExpandedRowModel(),\n        table.options.paginateExpandedRows,\n      ],\n      fn: () => _createExpandedRowModel(table),\n    })\n  }\n}\n\nfunction _createExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  const rowModel = table.getPreExpandedRowModel()\n  const expanded = table.atoms.expanded?.get()\n\n  if (\n    !rowModel.rows.length ||\n    (expanded !== true && !Object.keys(expanded ?? {}).length)\n  ) {\n    return rowModel\n  }\n\n  if (!table.options.paginateExpandedRows) {\n    // Only expand rows at this point if they are being paginated\n    return rowModel\n  }\n\n  return expandRows(rowModel)\n}\n\n/**\n * Expands a row model according to the current expanded row state.\n *\n * Expanded sub-rows are inserted into the flattened row order while preserving the original row hierarchy.\n */\nexport function expandRows<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(rowModel: RowModel<TFeatures, TData>): RowModel<TFeatures, TData> {\n  const expandedRows: Array<Row<TFeatures, TData>> = []\n\n  const handleRow = (row: Row<TFeatures, TData>) => {\n    expandedRows.push(row)\n\n    if (row.subRows.length && row_getIsExpanded(row)) {\n      row.subRows.forEach(handleRow)\n    }\n  }\n\n  rowModel.rows.forEach(handleRow)\n\n  return {\n    rows: expandedRows,\n    flatRows: rowModel.flatRows,\n    rowsById: rowModel.rowsById,\n  }\n}\n"],"mappings":";;;;;;;;;AAaA,SAAgB,yBAG0D;CACxE,QAAQ,WAAW;EACjB,MAAM,QAAQ;EACd,OAAOA,wBAAU;GACf,SAAS;GACT;GACA,QAAQ;GACR,gBAAgB;;;8BACd,MAAM,MAAM,wFAAU,IAAI;KAC1B,MAAM,uBAAuB;KAC7B,MAAM,QAAQ;IAChB;;GACA,UAAU,wBAAwB,KAAK;EACzC,CAAC;CACH;AACF;AAEA,SAAS,wBAGP,OAAqE;;CACrE,MAAM,WAAW,MAAM,uBAAuB;CAC9C,MAAM,qCAAW,MAAM,MAAM,0FAAU,IAAI;CAE3C,IACE,CAAC,SAAS,KAAK,UACd,aAAa,QAAQ,CAAC,OAAO,KAAK,YAAY,CAAC,CAAC,CAAC,CAAC,QAEnD,OAAO;CAGT,IAAI,CAAC,MAAM,QAAQ,sBAEjB,OAAO;CAGT,OAAO,WAAW,QAAQ;AAC5B;;;;;;AAOA,SAAgB,WAGd,UAAkE;CAClE,MAAM,eAA6C,CAAC;CAEpD,MAAM,aAAa,QAA+B;EAChD,aAAa,KAAK,GAAG;EAErB,IAAI,IAAI,QAAQ,UAAUC,oDAAkB,GAAG,GAC7C,IAAI,QAAQ,QAAQ,SAAS;CAEjC;CAEA,SAAS,KAAK,QAAQ,SAAS;CAE/B,OAAO;EACL,MAAM;EACN,UAAU,SAAS;EACnB,UAAU,SAAS;CACrB;AACF"}

package/dist/features/row-expanding/createExpandedRowModel.d.cts

@@ -1,21 +0,0 @@
-import { RowData } from "../../types/type-utils.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-import { Table } from "../../types/Table.cjs";
-import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.cjs";
-
-//#region src/features/row-expanding/createExpandedRowModel.d.ts
-/**
- * Creates a memoized expanded row model factory.
- *
- * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
- */
-declare function createExpandedRowModel<TFeatures extends TableFeatures, TData extends RowData = any>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
-/**
- * Expands a row model according to the current expanded row state.
- *
- * Expanded sub-rows are inserted into the flattened row order while preserving the original row hierarchy.
- */
-declare function expandRows<TFeatures extends TableFeatures, TData extends RowData = any>(rowModel: RowModel<TFeatures, TData>): RowModel<TFeatures, TData>;
-//#endregion
-export { createExpandedRowModel, expandRows };
-//# sourceMappingURL=createExpandedRowModel.d.cts.map