@tanstack/table-core 9.0.0-alpha.0 → 9.0.0-alpha.11

package/dist/esm/core/table/coreTablesFeature.types.d.ts

@@ -0,0 +1,105 @@
+import { Derived, Store } from '@tanstack/store';
+import { CoreFeatures } from '../coreFeatures.js';
+import { RowModelFns } from '../../types/RowModelFns.js';
+import { RowData, Updater } from '../../types/type-utils.js';
+import { TableFeatures } from '../../types/TableFeatures.js';
+import { CachedRowModels, CreateRowModels_All } from '../../types/RowModel.js';
+import { TableOptions } from '../../types/TableOptions.js';
+import { TableState } from '../../types/TableState.js';
+export interface TableMeta<TFeatures extends TableFeatures, TData extends RowData> {
+}
+export interface TableOptions_Table<TFeatures extends TableFeatures, TData extends RowData> {
+    /**
+     * The features that you want to enable for the table.
+     */
+    _features: TFeatures;
+    /**
+     * The row model options that you want to enable for the table.
+     */
+    _rowModels?: CreateRowModels_All<TFeatures, TData>;
+    /**
+     * Set this option to override any of the `autoReset...` feature options.
+     */
+    autoResetAll?: boolean;
+    /**
+     * The data for the table to display. When the `data` option changes reference, the table will reprocess the data.
+     */
+    data: Array<TData>;
+    /**
+     * Use this option to optionally pass initial state to the table. This state will be used when resetting various table states either automatically by the table (eg. `options.autoResetPageIndex`) or via functions like `table.resetRowSelection()`. Most reset function allow you optionally pass a flag to reset to a blank/default state instead of the initial state.
+     * Table state will not be reset when this object changes, which also means that the initial state object does not need to be stable.
+     */
+    initialState?: Partial<TableState<TFeatures>>;
+    /**
+     * This option is used to optionally implement the merging of table options.
+     */
+    mergeOptions?: (defaultOptions: TableOptions<TFeatures, TData>, options: Partial<TableOptions<TFeatures, TData>>) => TableOptions<TFeatures, TData>;
+    /**
+     * You can pass any object to `options.meta` and access it anywhere the `table` is available via `table.options.meta`.
+     */
+    meta?: TableMeta<TFeatures, TData>;
+    /**
+     * Pass in individual self-managed state to the table.
+     */
+    state?: Partial<TableState<TFeatures>>;
+    /**
+     * Optionally, provide your own external TanStack Store instance if you want to manage the table state externally.
+     */
+    store?: Store<TableState<TFeatures>>;
+}
+export interface Table_CoreProperties<TFeatures extends TableFeatures, TData extends RowData> {
+    /**
+     * The features that are enabled for the table.
+     */
+    _features: Partial<CoreFeatures> & TFeatures;
+    /**
+     * Prototype cache for Cell objects - shared by all cells in this table
+     */
+    _cellPrototype?: object;
+    /**
+     * Prototype cache for Column objects - shared by all columns in this table
+     */
+    _columnPrototype?: object;
+    /**
+     * Prototype cache for Header objects - shared by all headers in this table
+     */
+    _headerPrototype?: object;
+    /**
+     * The row model processing functions that are used to process the data by features.
+     */
+    _rowModelFns: RowModelFns<TFeatures, TData>;
+    /**
+     * The row models that are enabled for the table.
+     */
+    _rowModels: CachedRowModels<TFeatures, TData>;
+    /**
+     * Prototype cache for Row objects - shared by all rows in this table
+     */
+    _rowPrototype?: object;
+    /**
+     * The base store for the table. This can be used to write to the table state.
+     */
+    baseStore: Store<TableState<TFeatures>>;
+    /**
+     * This is the resolved initial state of the table.
+     */
+    initialState: TableState<TFeatures>;
+    /**
+     * A read-only reference to the table's current options.
+     */
+    options: TableOptions<TFeatures, TData>;
+    /**
+     * Where the table state is stored.
+     */
+    store: Derived<TableState<TFeatures>, [Store<TableState<TFeatures>>]>;
+}
+export interface Table_Table<TFeatures extends TableFeatures, TData extends RowData> extends Table_CoreProperties<TFeatures, TData> {
+    /**
+     * Call this function to reset the table state to the initial state.
+     */
+    reset: () => void;
+    /**
+     * This function can be used to update the table options.
+     */
+    setOptions: (newOptions: Updater<TableOptions<TFeatures, TData>>) => void;
+}

package/dist/esm/core/table/coreTablesFeature.utils.d.ts

@@ -0,0 +1,7 @@
+import { RowData, Updater } from '../../types/type-utils.js';
+import { TableFeatures } from '../../types/TableFeatures.js';
+import { Table_Internal } from '../../types/Table.js';
+import { TableOptions } from '../../types/TableOptions.js';
+export declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+export declare function table_mergeOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
+export declare function table_setOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<TableOptions<TFeatures, TData>>): void;

package/dist/esm/core/table/coreTablesFeature.utils.js

@@ -0,0 +1,23 @@
+import { functionalUpdate } from "../../utils.js";
+function table_reset(table) {
+  table.baseStore.setState(structuredClone(table.initialState));
+}
+function table_mergeOptions(table, newOptions) {
+  if (table.options.mergeOptions) {
+    return table.options.mergeOptions(table.options, newOptions);
+  }
+  return {
+    ...table.options,
+    ...newOptions
+  };
+}
+function table_setOptions(table, updater) {
+  const newOptions = functionalUpdate(updater, table.options);
+  table.options = table_mergeOptions(table, newOptions);
+}
+export {
+  table_mergeOptions,
+  table_reset,
+  table_setOptions
+};
+//# sourceMappingURL=coreTablesFeature.utils.js.map

package/dist/esm/core/table/coreTablesFeature.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreTablesFeature.utils.js","sources":["../../../../src/core/table/coreTablesFeature.utils.ts"],"sourcesContent":["import { functionalUpdate } from '../../utils'\nimport type { RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableOptions } from '../../types/TableOptions'\n\nexport function table_reset<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): void {\n  table.baseStore.setState(structuredClone(table.initialState))\n}\n\nexport function table_mergeOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  newOptions: TableOptions<TFeatures, TData>,\n) {\n  if (table.options.mergeOptions) {\n    return table.options.mergeOptions(table.options, newOptions)\n  }\n\n  return {\n    ...table.options,\n    ...newOptions,\n  }\n}\n\nexport function table_setOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<TableOptions<TFeatures, TData>>,\n): void {\n  const newOptions = functionalUpdate(updater, table.options)\n  table.options = table_mergeOptions(table, newOptions)\n}\n"],"names":[],"mappings":";AAMO,SAAS,YAGd,OAA+C;AAC/C,QAAM,UAAU,SAAS,gBAAgB,MAAM,YAAY,CAAC;AAC9D;AAEO,SAAS,mBAId,OACA,YACA;AACA,MAAI,MAAM,QAAQ,cAAc;AAC9B,WAAO,MAAM,QAAQ,aAAa,MAAM,SAAS,UAAU;AAAA,EAC7D;AAEA,SAAO;AAAA,IACL,GAAG,MAAM;AAAA,IACT,GAAG;AAAA,EAAA;AAEP;AAEO,SAAS,iBAId,OACA,SACM;AACN,QAAM,aAAa,iBAAiB,SAAS,MAAM,OAAO;AAC1D,QAAM,UAAU,mBAAmB,OAAO,UAAU;AACtD;"}

package/dist/esm/features/column-faceting/columnFacetingFeature.d.ts

@@ -0,0 +1,10 @@
+import { RowData } from '../../types/type-utils.js';
+import { TableFeature, TableFeatures } from '../../types/TableFeatures.js';
+interface ColumnFacetingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {
+}
+export declare function constructColumnFacetingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnFacetingFeatureConstructors<TFeatures, TData>>;
+/**
+ * The Column Faceting feature adds column faceting APIs to the column objects.
+ */
+export declare const columnFacetingFeature: TableFeature<ColumnFacetingFeatureConstructors<TableFeatures, RowData>>;
+export {};

package/dist/esm/features/column-faceting/columnFacetingFeature.js

@@ -0,0 +1,80 @@
+import { assignTableAPIs, callMemoOrStaticFn, assignPrototypeAPIs } from "../../utils.js";
+import { table_getGlobalFacetedUniqueValues, table_getGlobalFacetedMinMaxValues, table_getGlobalFacetedRowModel, column_getFacetedUniqueValues, column_getFacetedMinMaxValues, column_getFacetedRowModel } from "./columnFacetingFeature.utils.js";
+function constructColumnFacetingFeature() {
+  return {
+    assignColumnPrototype: (prototype, table) => {
+      assignPrototypeAPIs("columnFacetingFeature", prototype, table, {
+        column_getFacetedRowModel: {
+          memoDeps: () => [
+            table.getPreFilteredRowModel().rows,
+            table.store.state.columnFilters,
+            table.store.state.globalFilter,
+            table.getFilteredRowModel().rows
+          ],
+          fn: (column) => column_getFacetedRowModel(column, column.table)
+        },
+        column_getFacetedMinMaxValues: {
+          memoDeps: (column) => [
+            callMemoOrStaticFn(
+              column,
+              "getFacetedRowModel",
+              column_getFacetedRowModel,
+              column.table
+            ).flatRows
+          ],
+          fn: (column) => column_getFacetedMinMaxValues(column, column.table)
+        },
+        column_getFacetedUniqueValues: {
+          memoDeps: (column) => [
+            callMemoOrStaticFn(
+              column,
+              "getFacetedRowModel",
+              column_getFacetedRowModel,
+              column.table
+            ).flatRows
+          ],
+          fn: (column) => column_getFacetedUniqueValues(column, column.table)
+        }
+      });
+    },
+    constructTableAPIs: (table) => {
+      assignTableAPIs("columnFacetingFeature", table, {
+        table_getGlobalFacetedRowModel: {
+          memoDeps: () => [
+            table.getPreFilteredRowModel().rows,
+            table.store.state.columnFilters,
+            table.store.state.globalFilter,
+            table.getFilteredRowModel().rows
+          ],
+          fn: () => table_getGlobalFacetedRowModel(table)
+        },
+        table_getGlobalFacetedMinMaxValues: {
+          memoDeps: () => [
+            callMemoOrStaticFn(
+              table,
+              "getGlobalFacetedRowModel",
+              table_getGlobalFacetedRowModel
+            ).flatRows
+          ],
+          fn: () => table_getGlobalFacetedMinMaxValues(table)
+        },
+        table_getGlobalFacetedUniqueValues: {
+          memoDeps: () => [
+            callMemoOrStaticFn(
+              table,
+              "getGlobalFacetedRowModel",
+              table_getGlobalFacetedRowModel
+            ).flatRows
+          ],
+          fn: () => table_getGlobalFacetedUniqueValues(table)
+        }
+      });
+    }
+  };
+}
+const columnFacetingFeature = constructColumnFacetingFeature();
+export {
+  columnFacetingFeature,
+  constructColumnFacetingFeature
+};
+//# sourceMappingURL=columnFacetingFeature.js.map

package/dist/esm/features/column-faceting/columnFacetingFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnFacetingFeature.js","sources":["../../../../src/features/column-faceting/columnFacetingFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  callMemoOrStaticFn,\n} from '../../utils'\nimport {\n  column_getFacetedMinMaxValues,\n  column_getFacetedRowModel,\n  column_getFacetedUniqueValues,\n  table_getGlobalFacetedMinMaxValues,\n  table_getGlobalFacetedRowModel,\n  table_getGlobalFacetedUniqueValues,\n} from './columnFacetingFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\nimport type { Column_Internal } from '../../types/Column'\n// import type {\n//   CachedRowModel_Faceted,\n//   Column_ColumnFaceting,\n//   CreateRowModel_Faceted,\n// } from './columnFacetingFeature.types'\n\ninterface ColumnFacetingFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // CachedRowModel: CachedRowModel_Faceted<TFeatures, TData>\n  // Column: Column_ColumnFaceting<TFeatures, TData>\n  // CreateRowModels: CreateRowModel_Faceted<TFeatures, TData>\n}\n\nexport function constructColumnFacetingFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<ColumnFacetingFeatureConstructors<TFeatures, TData>> {\n  return {\n    assignColumnPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnFacetingFeature', prototype, table, {\n        column_getFacetedRowModel: {\n          memoDeps: () => [\n            table.getPreFilteredRowModel().rows,\n            table.store.state.columnFilters,\n            table.store.state.globalFilter,\n            table.getFilteredRowModel().rows,\n          ],\n          fn: (column) => column_getFacetedRowModel(column, column.table),\n        },\n        column_getFacetedMinMaxValues: {\n          memoDeps: (column: Column_Internal<TFeatures, TData>) => [\n            callMemoOrStaticFn(\n              column,\n              'getFacetedRowModel',\n              column_getFacetedRowModel,\n              column.table,\n            ).flatRows,\n          ],\n          fn: (column) => column_getFacetedMinMaxValues(column, column.table),\n        },\n        column_getFacetedUniqueValues: {\n          memoDeps: (column: Column_Internal<TFeatures, TData>) => [\n            callMemoOrStaticFn(\n              column,\n              'getFacetedRowModel',\n              column_getFacetedRowModel,\n              column.table,\n            ).flatRows,\n          ],\n          fn: (column) => column_getFacetedUniqueValues(column, column.table),\n        },\n      })\n    },\n\n    constructTableAPIs: (table) => {\n      assignTableAPIs('columnFacetingFeature', table, {\n        table_getGlobalFacetedRowModel: {\n          memoDeps: () => [\n            table.getPreFilteredRowModel().rows,\n            table.store.state.columnFilters,\n            table.store.state.globalFilter,\n            table.getFilteredRowModel().rows,\n          ],\n          fn: () => table_getGlobalFacetedRowModel(table),\n        },\n        table_getGlobalFacetedMinMaxValues: {\n          memoDeps: () => [\n            callMemoOrStaticFn(\n              table,\n              'getGlobalFacetedRowModel',\n              table_getGlobalFacetedRowModel,\n            ).flatRows,\n          ],\n          fn: () => table_getGlobalFacetedMinMaxValues(table),\n        },\n        table_getGlobalFacetedUniqueValues: {\n          memoDeps: () => [\n            callMemoOrStaticFn(\n              table,\n              'getGlobalFacetedRowModel',\n              table_getGlobalFacetedRowModel,\n            ).flatRows,\n          ],\n          fn: () => table_getGlobalFacetedUniqueValues(table),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Column Faceting feature adds column faceting APIs to the column objects.\n */\nexport const columnFacetingFeature = constructColumnFacetingFeature()\n"],"names":[],"mappings":";;AA+BO,SAAS,iCAGuD;AACrE,SAAO;AAAA,IACL,uBAAuB,CAAC,WAAW,UAAU;AAC3C,0BAAoB,yBAAyB,WAAW,OAAO;AAAA,QAC7D,2BAA2B;AAAA,UACzB,UAAU,MAAM;AAAA,YACd,MAAM,yBAAyB;AAAA,YAC/B,MAAM,MAAM,MAAM;AAAA,YAClB,MAAM,MAAM,MAAM;AAAA,YAClB,MAAM,sBAAsB;AAAA,UAAA;AAAA,UAE9B,IAAI,CAAC,WAAW,0BAA0B,QAAQ,OAAO,KAAK;AAAA,QAAA;AAAA,QAEhE,+BAA+B;AAAA,UAC7B,UAAU,CAAC,WAA8C;AAAA,YACvD;AAAA,cACE;AAAA,cACA;AAAA,cACA;AAAA,cACA,OAAO;AAAA,YAAA,EACP;AAAA,UAAA;AAAA,UAEJ,IAAI,CAAC,WAAW,8BAA8B,QAAQ,OAAO,KAAK;AAAA,QAAA;AAAA,QAEpE,+BAA+B;AAAA,UAC7B,UAAU,CAAC,WAA8C;AAAA,YACvD;AAAA,cACE;AAAA,cACA;AAAA,cACA;AAAA,cACA,OAAO;AAAA,YAAA,EACP;AAAA,UAAA;AAAA,UAEJ,IAAI,CAAC,WAAW,8BAA8B,QAAQ,OAAO,KAAK;AAAA,QAAA;AAAA,MACpE,CACD;AAAA,IACH;AAAA,IAEA,oBAAoB,CAAC,UAAU;AAC7B,sBAAgB,yBAAyB,OAAO;AAAA,QAC9C,gCAAgC;AAAA,UAC9B,UAAU,MAAM;AAAA,YACd,MAAM,yBAAyB;AAAA,YAC/B,MAAM,MAAM,MAAM;AAAA,YAClB,MAAM,MAAM,MAAM;AAAA,YAClB,MAAM,sBAAsB;AAAA,UAAA;AAAA,UAE9B,IAAI,MAAM,+BAA+B,KAAK;AAAA,QAAA;AAAA,QAEhD,oCAAoC;AAAA,UAClC,UAAU,MAAM;AAAA,YACd;AAAA,cACE;AAAA,cACA;AAAA,cACA;AAAA,YAAA,EACA;AAAA,UAAA;AAAA,UAEJ,IAAI,MAAM,mCAAmC,KAAK;AAAA,QAAA;AAAA,QAEpD,oCAAoC;AAAA,UAClC,UAAU,MAAM;AAAA,YACd;AAAA,cACE;AAAA,cACA;AAAA,cACA;AAAA,YAAA,EACA;AAAA,UAAA;AAAA,UAEJ,IAAI,MAAM,mCAAmC,KAAK;AAAA,QAAA;AAAA,MACpD,CACD;AAAA,IACH;AAAA,EAAA;AAEJ;AAKO,MAAM,wBAAwB,+BAAA;"}

package/dist/esm/features/column-faceting/columnFacetingFeature.types.d.ts

@@ -0,0 +1,68 @@
+import { Table } from '../../types/Table.js';
+import { RowData } from '../../types/type-utils.js';
+import { TableFeatures } from '../../types/TableFeatures.js';
+import { RowModel } from '../../core/row-models/coreRowModelsFeature.types';
+export interface Column_ColumnFaceting<TFeatures extends TableFeatures, TData extends RowData> {
+    /**
+     * A function that **computes and returns** a min/max tuple derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.
+     */
+    getFacetedMinMaxValues: () => undefined | [number, number];
+    /**
+     * A function that **computes and returns** a row model with all other column filters applied, excluding its own filter. Useful for displaying faceted result counts.
+     */
+    getFacetedRowModel: () => RowModel<TFeatures, TData>;
+    /**
+     * Returns a `Map` of unique values and their occurrences derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.
+     */
+    getFacetedUniqueValues: () => Map<any, number>;
+}
+export interface Table_RowModels_Faceted<TFeatures extends TableFeatures, TData extends RowData> {
+    /**
+     * A function that **computes and returns** a min/max tuple derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.
+     * > ⚠️ Requires that you pass a valid `getFacetedMinMaxValues` function to `options.getFacetedMinMaxValues`. A default implementation is provided via the exported `getFacetedMinMaxValues` function.
+     */
+    getFacetedMinMaxValues: () => undefined | [number, number];
+    /**
+     * Returns the row model with all other column filters applied, excluding its own filter. Useful for displaying faceted result counts.
+     * > ⚠️ Requires that you pass a valid `getFacetedRowModel` function to `options.facetedRowModel`. A default implementation is provided via the exported `getFacetedRowModel` function.
+     */
+    getFacetedRowModel: () => RowModel<TFeatures, TData>;
+    /**
+     * A function that **computes and returns** a `Map` of unique values and their occurrences derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.
+     * > ⚠️ Requires that you pass a valid `getFacetedUniqueValues` function to `options.getFacetedUniqueValues`. A default implementation is provided via the exported `getFacetedUniqueValues` function.
+     */
+    getFacetedUniqueValues: () => Map<any, number>;
+}
+export interface CreateRowModel_Faceted<TFeatures extends TableFeatures, TData extends RowData> {
+    /**
+     * This function is used to retrieve the faceted min/max values. If using server-side faceting, this function is not required. To use client-side faceting, pass the exported `getFacetedMinMaxValues()` from your adapter to your table or implement your own.
+     */
+    facetedMinMaxValues?: (table: Table<TFeatures, TData>, columnId: string) => () => [number, number] | undefined;
+    /**
+     * This function is used to retrieve the faceted row model. If using server-side faceting, this function is not required. To use client-side faceting, pass the exported `getFacetedRowModel()` from your adapter to your table or implement your own.
+     */
+    facetedRowModel?: (table: Table<TFeatures, TData>, columnId: string) => () => RowModel<TFeatures, TData>;
+    /**
+     * This function is used to retrieve the faceted unique values. If using server-side faceting, this function is not required. To use client-side faceting, pass the exported `getFacetedUniqueValues()` from your adapter to your table or implement your own.
+     */
+    facetedUniqueValues?: (table: Table<TFeatures, TData>, columnId: string) => () => Map<any, number>;
+}
+export interface CachedRowModel_Faceted<TFeatures extends TableFeatures, TData extends RowData> {
+    facetedRowModel?: (columnId: string) => () => RowModel<TFeatures, TData>;
+    facetedMinMaxValues?: (columnId: string) => [number, number];
+    facetedUniqueValues?: (columnId: string) => Map<any, number>;
+}
+export interface Table_ColumnFaceting<TFeatures extends TableFeatures, TData extends RowData> {
+    /**
+     * Returns the min and max values for the global filter.
+     */
+    getGlobalFacetedMinMaxValues: () => undefined | [number, number];
+    /**
+     * Returns the row model for the table after **global** filtering has been applied.
+     */
+    getGlobalFacetedRowModel: () => RowModel<TFeatures, TData>;
+    /**
+     * Returns the faceted unique values for the global filter.
+     */
+    getGlobalFacetedUniqueValues: () => Map<any, number>;
+}

package/dist/esm/features/column-faceting/columnFacetingFeature.utils.d.ts

@@ -0,0 +1,11 @@
+import { CellData, RowData } from '../../types/type-utils.js';
+import { TableFeatures } from '../../types/TableFeatures.js';
+import { RowModel } from '../../core/row-models/coreRowModelsFeature.types';
+import { Table_Internal } from '../../types/Table.js';
+import { Column_Internal } from '../../types/Column.js';
+export declare function column_getFacetedMinMaxValues<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>, table: Table_Internal<TFeatures, TData>): [number, number] | undefined;
+export declare function column_getFacetedRowModel<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue> | undefined, table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
+export declare function column_getFacetedUniqueValues<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>, table: Table_Internal<TFeatures, TData>): Map<any, number>;
+export declare function table_getGlobalFacetedMinMaxValues<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): undefined | [number, number];
+export declare function table_getGlobalFacetedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
+export declare function table_getGlobalFacetedUniqueValues<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Map<any, number>;

package/dist/esm/features/column-faceting/columnFacetingFeature.utils.js

@@ -0,0 +1,33 @@
+function column_getFacetedMinMaxValues(column, table) {
+  const facetedMinMaxValuesFn = table.options._rowModels?.facetedMinMaxValues?.(table, column.id) ?? (() => void 0);
+  return facetedMinMaxValuesFn();
+}
+function column_getFacetedRowModel(column, table) {
+  const facetedRowModelFn = table.options._rowModels?.facetedRowModel?.(table, column?.id ?? "") ?? (() => table.getPreFilteredRowModel());
+  return facetedRowModelFn();
+}
+function column_getFacetedUniqueValues(column, table) {
+  const facetedUniqueValuesFn = table.options._rowModels?.facetedUniqueValues?.(table, column.id) ?? (() => /* @__PURE__ */ new Map());
+  return facetedUniqueValuesFn();
+}
+function table_getGlobalFacetedMinMaxValues(table) {
+  const facetedMinMaxValuesFn = table.options._rowModels?.facetedMinMaxValues?.(table, "__global__") ?? (() => void 0);
+  return facetedMinMaxValuesFn();
+}
+function table_getGlobalFacetedRowModel(table) {
+  const facetedRowModelFn = table.options._rowModels?.facetedRowModel?.(table, "__global__") ?? (() => table.getPreFilteredRowModel());
+  return facetedRowModelFn();
+}
+function table_getGlobalFacetedUniqueValues(table) {
+  const facetedUniqueValuesFn = table.options._rowModels?.facetedUniqueValues?.(table, "__global__") ?? (() => /* @__PURE__ */ new Map());
+  return facetedUniqueValuesFn();
+}
+export {
+  column_getFacetedMinMaxValues,
+  column_getFacetedRowModel,
+  column_getFacetedUniqueValues,
+  table_getGlobalFacetedMinMaxValues,
+  table_getGlobalFacetedRowModel,
+  table_getGlobalFacetedUniqueValues
+};
+//# sourceMappingURL=columnFacetingFeature.utils.js.map

package/dist/esm/features/column-faceting/columnFacetingFeature.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnFacetingFeature.utils.js","sources":["../../../../src/features/column-faceting/columnFacetingFeature.utils.ts"],"sourcesContent":["import type { CellData, RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Column_Internal } from '../../types/Column'\n\nexport function column_getFacetedMinMaxValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(\n  column: Column_Internal<TFeatures, TData, TValue>,\n  table: Table_Internal<TFeatures, TData>,\n): [number, number] | undefined {\n  const facetedMinMaxValuesFn =\n    table.options._rowModels?.facetedMinMaxValues?.(table, column.id) ??\n    (() => undefined)\n  return facetedMinMaxValuesFn()\n}\n\nexport function column_getFacetedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(\n  column: Column_Internal<TFeatures, TData, TValue> | undefined,\n  table: Table_Internal<TFeatures, TData>,\n): RowModel<TFeatures, TData> {\n  const facetedRowModelFn =\n    table.options._rowModels?.facetedRowModel?.(table, column?.id ?? '') ??\n    (() => table.getPreFilteredRowModel())\n  return facetedRowModelFn()\n}\n\nexport function column_getFacetedUniqueValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(\n  column: Column_Internal<TFeatures, TData, TValue>,\n  table: Table_Internal<TFeatures, TData>,\n): Map<any, number> {\n  const facetedUniqueValuesFn =\n    table.options._rowModels?.facetedUniqueValues?.(table, column.id) ??\n    (() => new Map<any, number>())\n  return facetedUniqueValuesFn()\n}\n\nexport function table_getGlobalFacetedMinMaxValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): undefined | [number, number] {\n  const facetedMinMaxValuesFn =\n    table.options._rowModels?.facetedMinMaxValues?.(table, '__global__') ??\n    (() => undefined)\n  return facetedMinMaxValuesFn()\n}\n\nexport function table_getGlobalFacetedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  const facetedRowModelFn =\n    table.options._rowModels?.facetedRowModel?.(table, '__global__') ??\n    (() => table.getPreFilteredRowModel())\n  return facetedRowModelFn()\n}\n\nexport function table_getGlobalFacetedUniqueValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): Map<any, number> {\n  const facetedUniqueValuesFn =\n    table.options._rowModels?.facetedUniqueValues?.(table, '__global__') ??\n    (() => new Map())\n  return facetedUniqueValuesFn()\n}\n"],"names":[],"mappings":"AAMO,SAAS,8BAKd,QACA,OAC8B;AAC9B,QAAM,wBACJ,MAAM,QAAQ,YAAY,sBAAsB,OAAO,OAAO,EAAE,MAC/D,MAAM;AACT,SAAO,sBAAA;AACT;AAEO,SAAS,0BAKd,QACA,OAC4B;AAC5B,QAAM,oBACJ,MAAM,QAAQ,YAAY,kBAAkB,OAAO,QAAQ,MAAM,EAAE,MAClE,MAAM,MAAM,uBAAA;AACf,SAAO,kBAAA;AACT;AAEO,SAAS,8BAKd,QACA,OACkB;AAClB,QAAM,wBACJ,MAAM,QAAQ,YAAY,sBAAsB,OAAO,OAAO,EAAE,MAC/D,MAAM,oBAAI,IAAA;AACb,SAAO,sBAAA;AACT;AAEO,SAAS,mCAGd,OAAuE;AACvE,QAAM,wBACJ,MAAM,QAAQ,YAAY,sBAAsB,OAAO,YAAY,MAClE,MAAM;AACT,SAAO,sBAAA;AACT;AAEO,SAAS,+BAGd,OAAqE;AACrE,QAAM,oBACJ,MAAM,QAAQ,YAAY,kBAAkB,OAAO,YAAY,MAC9D,MAAM,MAAM,uBAAA;AACf,SAAO,kBAAA;AACT;AAEO,SAAS,mCAGd,OAA2D;AAC3D,QAAM,wBACJ,MAAM,QAAQ,YAAY,sBAAsB,OAAO,YAAY,MAClE,MAAM,oBAAI;AACb,SAAO,sBAAA;AACT;"}

package/dist/esm/features/column-faceting/createFacetedMinMaxValues.d.ts

@@ -0,0 +1,4 @@
+import { Table } from '../../types/Table.js';
+import { TableFeatures } from '../../types/TableFeatures.js';
+import { RowData } from '../../types/type-utils.js';
+export declare function createFacetedMinMaxValues<TFeatures extends TableFeatures, TData extends RowData = any>(): (table: Table<TFeatures, TData>, columnId: string) => () => undefined | [number, number];

package/dist/esm/features/column-faceting/createFacetedMinMaxValues.js

@@ -0,0 +1,41 @@
+import { tableMemo, callMemoOrStaticFn } from "../../utils.js";
+import { column_getFacetedRowModel } from "./columnFacetingFeature.utils.js";
+function createFacetedMinMaxValues() {
+  return (_table, columnId) => {
+    const table = _table;
+    return tableMemo({
+      feature: "columnFacetingFeature",
+      fn: (flatRows) => _createFacetedMinMaxValues(columnId, flatRows),
+      fnName: "table.getFacetedMinMaxValues",
+      memoDeps: () => {
+        const column = table.getColumn(columnId);
+        if (!column) return [table.getPreFilteredRowModel().flatRows];
+        return [
+          callMemoOrStaticFn(
+            column,
+            "getFacetedRowModel",
+            column_getFacetedRowModel,
+            table
+          ).flatRows
+        ];
+      },
+      table
+    });
+  };
+}
+function _createFacetedMinMaxValues(columnId, flatRows) {
+  if (!flatRows.length) return void 0;
+  const numericValues = flatRows.map((flatRow) => flatRow.getValue(columnId)).map(Number).filter((value) => !Number.isNaN(value));
+  if (!numericValues.length) return void 0;
+  let facetedMinValue = numericValues[0];
+  let facetedMaxValue = numericValues[0];
+  for (const value of numericValues) {
+    if (value < facetedMinValue) facetedMinValue = value;
+    if (value > facetedMaxValue) facetedMaxValue = value;
+  }
+  return [facetedMinValue, facetedMaxValue];
+}
+export {
+  createFacetedMinMaxValues
+};
+//# sourceMappingURL=createFacetedMinMaxValues.js.map

package/dist/esm/features/column-faceting/createFacetedMinMaxValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFacetedMinMaxValues.js","sources":["../../../../src/features/column-faceting/createFacetedMinMaxValues.ts"],"sourcesContent":["import { callMemoOrStaticFn, tableMemo } from '../../utils'\nimport { column_getFacetedRowModel } from './columnFacetingFeature.utils'\nimport type { Row } from '../../types/Row'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\n\nexport function createFacetedMinMaxValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(): (\n  table: Table<TFeatures, TData>,\n  columnId: string,\n) => () => undefined | [number, number] {\n  return (_table, columnId) => {\n    const table = _table as Table_Internal<TFeatures, TData>\n    return tableMemo({\n      feature: 'columnFacetingFeature',\n      fn: (flatRows) => _createFacetedMinMaxValues(columnId, flatRows),\n      fnName: 'table.getFacetedMinMaxValues',\n      memoDeps: () => {\n        const column = table.getColumn(columnId)\n        if (!column) return [table.getPreFilteredRowModel().flatRows]\n        return [\n          callMemoOrStaticFn(\n            column,\n            'getFacetedRowModel',\n            column_getFacetedRowModel,\n            table,\n          ).flatRows,\n        ]\n      },\n      table,\n    })\n  }\n}\n\nfunction _createFacetedMinMaxValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  columnId: string,\n  flatRows: Array<Row<TFeatures, TData>>,\n): undefined | [number, number] {\n  if (!flatRows.length) return undefined\n\n  const numericValues = flatRows\n    .map((flatRow) => flatRow.getValue(columnId))\n    .map(Number)\n    .filter((value) => !Number.isNaN(value))\n\n  if (!numericValues.length) return undefined\n\n  let facetedMinValue = numericValues[0]!\n  let facetedMaxValue = numericValues[0]!\n\n  for (const value of numericValues) {\n    if (value < facetedMinValue) facetedMinValue = value\n    if (value > facetedMaxValue) facetedMaxValue = value\n  }\n\n  return [facetedMinValue, facetedMaxValue]\n}\n"],"names":[],"mappings":";;AAOO,SAAS,4BAMwB;AACtC,SAAO,CAAC,QAAQ,aAAa;AAC3B,UAAM,QAAQ;AACd,WAAO,UAAU;AAAA,MACf,SAAS;AAAA,MACT,IAAI,CAAC,aAAa,2BAA2B,UAAU,QAAQ;AAAA,MAC/D,QAAQ;AAAA,MACR,UAAU,MAAM;AACd,cAAM,SAAS,MAAM,UAAU,QAAQ;AACvC,YAAI,CAAC,OAAQ,QAAO,CAAC,MAAM,uBAAA,EAAyB,QAAQ;AAC5D,eAAO;AAAA,UACL;AAAA,YACE;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UAAA,EACA;AAAA,QAAA;AAAA,MAEN;AAAA,MACA;AAAA,IAAA,CACD;AAAA,EACH;AACF;AAEA,SAAS,2BAIP,UACA,UAC8B;AAC9B,MAAI,CAAC,SAAS,OAAQ,QAAO;AAE7B,QAAM,gBAAgB,SACnB,IAAI,CAAC,YAAY,QAAQ,SAAS,QAAQ,CAAC,EAC3C,IAAI,MAAM,EACV,OAAO,CAAC,UAAU,CAAC,OAAO,MAAM,KAAK,CAAC;AAEzC,MAAI,CAAC,cAAc,OAAQ,QAAO;AAElC,MAAI,kBAAkB,cAAc,CAAC;AACrC,MAAI,kBAAkB,cAAc,CAAC;AAErC,aAAW,SAAS,eAAe;AACjC,QAAI,QAAQ,gBAAiB,mBAAkB;AAC/C,QAAI,QAAQ,gBAAiB,mBAAkB;AAAA,EACjD;AAEA,SAAO,CAAC,iBAAiB,eAAe;AAC1C;"}

package/dist/esm/features/column-faceting/createFacetedRowModel.d.ts

@@ -0,0 +1,5 @@
+import { Table } from '../../types/Table.js';
+import { TableFeatures } from '../../types/TableFeatures.js';
+import { RowModel } from '../../core/row-models/coreRowModelsFeature.types';
+import { RowData } from '../../types/type-utils.js';
+export declare function createFacetedRowModel<TFeatures extends TableFeatures, TData extends RowData = any>(): (table: Table<TFeatures, TData>, columnId: string) => () => RowModel<TFeatures, TData>;

package/dist/esm/features/column-faceting/createFacetedRowModel.js

@@ -0,0 +1,47 @@
+import { tableMemo } from "../../utils.js";
+import { filterRows } from "../column-filtering/filterRowsUtils.js";
+function createFacetedRowModel() {
+  return (_table, columnId) => {
+    const table = _table;
+    return tableMemo({
+      feature: "columnFacetingFeature",
+      table,
+      fnName: "createFacetedRowModel",
+      memoDeps: () => [
+        table.getPreFilteredRowModel(),
+        table.store.state.columnFilters,
+        table.store.state.globalFilter,
+        table.getFilteredRowModel()
+      ],
+      fn: (preRowModel, columnFilters, globalFilter) => _createFacetedRowModel(
+        table,
+        columnId,
+        preRowModel,
+        columnFilters,
+        globalFilter
+      )
+    });
+  };
+}
+function _createFacetedRowModel(table, columnId, preRowModel, columnFilters, globalFilter) {
+  if (!preRowModel.rows.length || !columnFilters?.length && !globalFilter) {
+    return preRowModel;
+  }
+  const filterableIds = [
+    ...columnFilters?.map((d) => d.id).filter((d) => d !== columnId) ?? [],
+    globalFilter ? "__global__" : void 0
+  ].filter(Boolean);
+  const filterRowsImpl = (row) => {
+    for (const colId of filterableIds) {
+      if (row.columnFilters?.[colId] === false) {
+        return false;
+      }
+    }
+    return true;
+  };
+  return filterRows(preRowModel.rows, filterRowsImpl, table);
+}
+export {
+  createFacetedRowModel
+};
+//# sourceMappingURL=createFacetedRowModel.js.map

package/dist/esm/features/column-faceting/createFacetedRowModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFacetedRowModel.js","sources":["../../../../src/features/column-faceting/createFacetedRowModel.ts"],"sourcesContent":["import { tableMemo } from '../../utils'\nimport { filterRows } from '../column-filtering/filterRowsUtils'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type {\n  ColumnFiltersState,\n  Row_ColumnFiltering,\n} from '../column-filtering/columnFilteringFeature.types'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'\nimport type { Row } from '../../types/Row'\nimport type { RowData } from '../../types/type-utils'\n\nexport function createFacetedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(): (\n  table: Table<TFeatures, TData>,\n  columnId: string,\n) => () => RowModel<TFeatures, TData> {\n  return (_table, columnId) => {\n    const table = _table as Table_Internal<TFeatures, TData>\n    return tableMemo({\n      feature: 'columnFacetingFeature',\n      table,\n      fnName: 'createFacetedRowModel',\n      memoDeps: () => [\n        table.getPreFilteredRowModel(),\n        table.store.state.columnFilters,\n        table.store.state.globalFilter,\n        table.getFilteredRowModel(),\n      ],\n      fn: (preRowModel, columnFilters, globalFilter) =>\n        _createFacetedRowModel(\n          table,\n          columnId,\n          preRowModel,\n          columnFilters,\n          globalFilter,\n        ),\n    })\n  }\n}\n\nfunction _createFacetedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  columnId: string,\n  preRowModel: RowModel<TFeatures, TData>,\n  columnFilters?: ColumnFiltersState,\n  globalFilter?: string,\n) {\n  if (!preRowModel.rows.length || (!columnFilters?.length && !globalFilter)) {\n    return preRowModel\n  }\n\n  const filterableIds = [\n    ...(columnFilters?.map((d) => d.id).filter((d) => d !== columnId) ?? []),\n    globalFilter ? '__global__' : undefined,\n  ].filter(Boolean) as Array<string>\n\n  const filterRowsImpl = (\n    row: Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>,\n  ) => {\n    // Horizontally filter rows through each column\n    for (const colId of filterableIds) {\n      if (row.columnFilters?.[colId] === false) {\n        return false\n      }\n    }\n    return true\n  }\n\n  return filterRows(preRowModel.rows, filterRowsImpl, table)\n}\n"],"names":[],"mappings":";;AAYO,SAAS,wBAMsB;AACpC,SAAO,CAAC,QAAQ,aAAa;AAC3B,UAAM,QAAQ;AACd,WAAO,UAAU;AAAA,MACf,SAAS;AAAA,MACT;AAAA,MACA,QAAQ;AAAA,MACR,UAAU,MAAM;AAAA,QACd,MAAM,uBAAA;AAAA,QACN,MAAM,MAAM,MAAM;AAAA,QAClB,MAAM,MAAM,MAAM;AAAA,QAClB,MAAM,oBAAA;AAAA,MAAoB;AAAA,MAE5B,IAAI,CAAC,aAAa,eAAe,iBAC/B;AAAA,QACE;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAAA,IACF,CACH;AAAA,EACH;AACF;AAEA,SAAS,uBAIP,OACA,UACA,aACA,eACA,cACA;AACA,MAAI,CAAC,YAAY,KAAK,UAAW,CAAC,eAAe,UAAU,CAAC,cAAe;AACzE,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB;AAAA,IACpB,GAAI,eAAe,IAAI,CAAC,MAAM,EAAE,EAAE,EAAE,OAAO,CAAC,MAAM,MAAM,QAAQ,KAAK,CAAA;AAAA,IACrE,eAAe,eAAe;AAAA,EAAA,EAC9B,OAAO,OAAO;AAEhB,QAAM,iBAAiB,CACrB,QACG;AAEH,eAAW,SAAS,eAAe;AACjC,UAAI,IAAI,gBAAgB,KAAK,MAAM,OAAO;AACxC,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAEA,SAAO,WAAW,YAAY,MAAM,gBAAgB,KAAK;AAC3D;"}

package/dist/esm/features/column-faceting/createFacetedUniqueValues.d.ts

@@ -0,0 +1,4 @@
+import { Table } from '../../types/Table.js';
+import { TableFeatures } from '../../types/TableFeatures.js';
+import { RowData } from '../../types/type-utils.js';
+export declare function createFacetedUniqueValues<TFeatures extends TableFeatures, TData extends RowData = any>(): (table: Table<TFeatures, TData>, columnId: string) => () => Map<any, number>;

package/dist/esm/features/column-faceting/createFacetedUniqueValues.js

@@ -0,0 +1,46 @@
+import { tableMemo, callMemoOrStaticFn } from "../../utils.js";
+import { column_getFacetedRowModel } from "./columnFacetingFeature.utils.js";
+function createFacetedUniqueValues() {
+  return (_table, columnId) => {
+    const table = _table;
+    return tableMemo({
+      feature: "columnFacetingFeature",
+      table,
+      fnName: "table.getFacetedUniqueValues",
+      memoDeps: () => {
+        const column = table.getColumn(columnId);
+        if (!column) return [table.getPreFilteredRowModel().flatRows];
+        return [
+          callMemoOrStaticFn(
+            column,
+            "getFacetedRowModel",
+            column_getFacetedRowModel,
+            table
+          ).flatRows
+        ];
+      },
+      fn: (flatRows) => _createFacetedUniqueValues(columnId, flatRows)
+    });
+  };
+}
+function _createFacetedUniqueValues(columnId, flatRows) {
+  const facetedUniqueValues = /* @__PURE__ */ new Map();
+  for (const row of flatRows) {
+    const values = row.getUniqueValues(columnId);
+    for (const value of values) {
+      if (facetedUniqueValues.has(value)) {
+        facetedUniqueValues.set(
+          value,
+          (facetedUniqueValues.get(value) ?? 0) + 1
+        );
+      } else {
+        facetedUniqueValues.set(value, 1);
+      }
+    }
+  }
+  return facetedUniqueValues;
+}
+export {
+  createFacetedUniqueValues
+};
+//# sourceMappingURL=createFacetedUniqueValues.js.map

package/dist/esm/features/column-faceting/createFacetedUniqueValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFacetedUniqueValues.js","sources":["../../../../src/features/column-faceting/createFacetedUniqueValues.ts"],"sourcesContent":["import { callMemoOrStaticFn, tableMemo } from '../../utils'\nimport { column_getFacetedRowModel } from './columnFacetingFeature.utils'\nimport type { Row } from '../../types/Row'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\n\nexport function createFacetedUniqueValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(): (\n  table: Table<TFeatures, TData>,\n  columnId: string,\n) => () => Map<any, number> {\n  return (_table, columnId) => {\n    const table = _table as Table_Internal<TFeatures, TData>\n    return tableMemo({\n      feature: 'columnFacetingFeature',\n      table,\n      fnName: 'table.getFacetedUniqueValues',\n      memoDeps: () => {\n        const column = table.getColumn(columnId)\n        if (!column) return [table.getPreFilteredRowModel().flatRows]\n        return [\n          callMemoOrStaticFn(\n            column,\n            'getFacetedRowModel',\n            column_getFacetedRowModel,\n            table,\n          ).flatRows,\n        ]\n      },\n      fn: (flatRows) => _createFacetedUniqueValues(columnId, flatRows),\n    })\n  }\n}\n\nfunction _createFacetedUniqueValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(columnId: string, flatRows: Array<Row<TFeatures, TData>>): Map<any, number> {\n  const facetedUniqueValues = new Map<any, number>()\n\n  for (const row of flatRows) {\n    const values = row.getUniqueValues(columnId)\n\n    for (const value of values) {\n      if (facetedUniqueValues.has(value)) {\n        facetedUniqueValues.set(\n          value,\n          (facetedUniqueValues.get(value) ?? 0) + 1,\n        )\n      } else {\n        facetedUniqueValues.set(value, 1)\n      }\n    }\n  }\n\n  return facetedUniqueValues\n}\n"],"names":[],"mappings":";;AAOO,SAAS,4BAMY;AAC1B,SAAO,CAAC,QAAQ,aAAa;AAC3B,UAAM,QAAQ;AACd,WAAO,UAAU;AAAA,MACf,SAAS;AAAA,MACT;AAAA,MACA,QAAQ;AAAA,MACR,UAAU,MAAM;AACd,cAAM,SAAS,MAAM,UAAU,QAAQ;AACvC,YAAI,CAAC,OAAQ,QAAO,CAAC,MAAM,uBAAA,EAAyB,QAAQ;AAC5D,eAAO;AAAA,UACL;AAAA,YACE;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UAAA,EACA;AAAA,QAAA;AAAA,MAEN;AAAA,MACA,IAAI,CAAC,aAAa,2BAA2B,UAAU,QAAQ;AAAA,IAAA,CAChE;AAAA,EACH;AACF;AAEA,SAAS,2BAGP,UAAkB,UAA0D;AAC5E,QAAM,0CAA0B,IAAA;AAEhC,aAAW,OAAO,UAAU;AAC1B,UAAM,SAAS,IAAI,gBAAgB,QAAQ;AAE3C,eAAW,SAAS,QAAQ;AAC1B,UAAI,oBAAoB,IAAI,KAAK,GAAG;AAClC,4BAAoB;AAAA,UAClB;AAAA,WACC,oBAAoB,IAAI,KAAK,KAAK,KAAK;AAAA,QAAA;AAAA,MAE5C,OAAO;AACL,4BAAoB,IAAI,OAAO,CAAC;AAAA,MAClC;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;"}

package/dist/esm/features/column-filtering/columnFilteringFeature.d.ts

@@ -0,0 +1,11 @@
+import { RowData } from '../../types/type-utils.js';
+import { TableFeature, TableFeatures } from '../../types/TableFeatures.js';
+interface ColumnFilteringFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {
+}
+export declare function constructColumnFilteringFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnFilteringFeatureConstructors<TFeatures, TData>>;
+/**
+ * The Column Filtering feature adds column filtering state and APIs to the table, row, and column objects.
+ * **Note:** This does not include Global Filtering. The globalFilteringFeature feature has been split out into its own standalone feature.
+ */
+export declare const columnFilteringFeature: TableFeature<ColumnFilteringFeatureConstructors<TableFeatures, RowData>>;
+export {};