@tanstack/table-core 9.0.0-alpha.6 → 9.0.0-beta.1

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

@@ -0,0 +1,71 @@
+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.types.d.ts

@@ -0,0 +1,71 @@
+import { CellData, OnChangeFn, RowData, Updater } from "../../types/type-utils.js";
+import { FilterFn, FilterFnOption } from "../column-filtering/columnFilteringFeature.types.js";
+import { Column } from "../../types/Column.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+
+//#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.ts.map

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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1 @@
+{"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, TData>> | undefined =\n    table._rowModelFns.filterFns\n\n  return isFunction(globalFilterFn)\n    ? globalFilterFn\n    : globalFilterFn === 'auto'\n      ? table_getGlobalAutoFilterFn()\n      : filterFns?.[globalFilterFn as string]\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;CAErB,OAAOC,yBAAW,cAAc,IAC5B,iBACA,mBAAmB,SACjB,4BAA4B,0DAC5B,UAAY;AACpB;;;;;;;;;;;;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

@@ -0,0 +1,72 @@
+import { CellData, RowData } from "../../types/type-utils.cjs";
+import { FilterFn } from "../column-filtering/columnFilteringFeature.types.cjs";
+import { Column_Internal } from "../../types/Column.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(): FilterFn<any, any>;
+/**
+ * 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.d.ts

@@ -0,0 +1,72 @@
+import { CellData, RowData } from "../../types/type-utils.js";
+import { FilterFn } from "../column-filtering/columnFilteringFeature.types.js";
+import { Column_Internal } from "../../types/Column.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+import { Table_Internal } from "../../types/Table.js";
+
+//#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(): FilterFn<any, any>;
+/**
+ * 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.ts.map

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

@@ -0,0 +1,84 @@
+import { cloneState, isFunction } from "../../utils.js";
+import { filterFn_includesString } from "../../fns/filterFns.js";
+
+//#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 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 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 : cloneState(table.initialState.globalFilter));
+}
+
+//#endregion
+export { column_getCanGlobalFilter, table_getGlobalAutoFilterFn, table_getGlobalFilterFn, table_resetGlobalFilter, table_setGlobalFilter };
+//# sourceMappingURL=globalFilteringFeature.utils.js.map

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

@@ -0,0 +1 @@
+{"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, TData>> | undefined =\n    table._rowModelFns.filterFns\n\n  return isFunction(globalFilterFn)\n    ? globalFilterFn\n    : globalFilterFn === 'auto'\n      ? table_getGlobalAutoFilterFn()\n      : filterFns?.[globalFilterFn as string]\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;CAErB,OAAO,WAAW,cAAc,IAC5B,iBACA,mBAAmB,SACjB,4BAA4B,0DAC5B,UAAY;AACpB;;;;;;;;;;;;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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1 @@
+{"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_Internal<TFeatures, TData> = _table\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,QAA0C;EAChD,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

@@ -0,0 +1,21 @@
+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

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

@@ -0,0 +1,21 @@
+import { RowData } from "../../types/type-utils.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+import { Table } from "../../types/Table.js";
+import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
+
+//#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.ts.map

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

@@ -0,0 +1,58 @@
+import { tableMemo } from "../../utils.js";
+import { row_getIsExpanded } from "./rowExpandingFeature.utils.js";
+
+//#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 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 && row_getIsExpanded(row)) row.subRows.forEach(handleRow);
+	};
+	rowModel.rows.forEach(handleRow);
+	return {
+		rows: expandedRows,
+		flatRows: rowModel.flatRows,
+		rowsById: rowModel.rowsById
+	};
+}
+
+//#endregion
+export { createExpandedRowModel, expandRows };
+//# sourceMappingURL=createExpandedRowModel.js.map