@tanstack/table-core 9.0.0-alpha.46 → 9.0.0-alpha.48

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

@@ -6,32 +6,38 @@ import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
 //#region src/features/column-faceting/columnFacetingFeature.types.d.ts
 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.
+   * Computes min/max numeric facet values for this column.
    */
   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.
+   * Computes the row model used to derive this column's facet values.
+   *
+   * Other column filters are applied, while this column's own filter is
+   * excluded.
    */
   getFacetedRowModel: () => RowModel<TFeatures, TData>;
   /**
-   * Returns a `Map` of unique values and their occurrences derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.
+   * Computes unique facet values and occurrence counts for this column.
    */
   getFacetedUniqueValues: () => Map<any, number>;
 }
 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 `facetedMinMaxValues` row model factory in `_rowModels`. A default implementation is provided via the exported `createFacetedMinMaxValues` function.
+   * Computes min/max numeric facet values for the active faceting context.
+   *
+   * Requires a `facetedMinMaxValues` row-model factory in `_rowModels`.
    */
   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 `facetedRowModel` row model factory in `_rowModels`. A default implementation is provided via the exported `createFacetedRowModel` function.
+   * Computes the row model used to derive facet values.
+   *
+   * Requires a `facetedRowModel` row-model factory in `_rowModels`.
    */
   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 `facetedUniqueValues` row model factory in `_rowModels`. A default implementation is provided via the exported `createFacetedUniqueValues` function.
+   * Computes unique facet values and occurrence counts.
+   *
+   * Requires a `facetedUniqueValues` row-model factory in `_rowModels`.
    */
   getFacetedUniqueValues: () => Map<any, number>;
 }
@@ -66,7 +72,7 @@ interface Table_ColumnFaceting<TFeatures extends TableFeatures, TData extends Ro
    */
   getGlobalFacetedMinMaxValues: () => undefined | [number, number];
   /**
-   * Returns the row model for the table after **global** filtering has been applied.
+   * Computes the row model used to derive global facet values.
    */
   getGlobalFacetedRowModel: () => RowModel<TFeatures, TData>;
   /**

package/dist/features/column-faceting/columnFacetingFeature.utils.cjs

@@ -1,13 +1,14 @@
 
 //#region src/features/column-faceting/columnFacetingFeature.utils.ts
 /**
-* Returns faceted min max values for a column.
+* Computes min and max numeric facet values for one column.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* The configured `facetedMinMaxValues` row-model factory owns the calculation.
+* If no factory is registered, the result is `undefined`.
 *
 * @example
 * ```ts
-* const value = column_getFacetedMinMaxValues(column)
+* const range = column_getFacetedMinMaxValues(column, table)
 * ```
 */
 function column_getFacetedMinMaxValues(column, table) {
@@ -15,13 +16,15 @@ function column_getFacetedMinMaxValues(column, table) {
 	return (((_table$options$_rowMo = table.options._rowModels) === null || _table$options$_rowMo === void 0 || (_table$options$_rowMo2 = _table$options$_rowMo.facetedMinMaxValues) === null || _table$options$_rowMo2 === void 0 ? void 0 : _table$options$_rowMo2.call(_table$options$_rowMo, table, column.id)) ?? (() => void 0))();
 }
 /**
-* Returns faceted row model for a column.
+* Computes the row model used to derive one column's facet values.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* The faceted row model normally applies every other active filter while
+* excluding this column's own filter. If no factory is registered, the
+* pre-filtered row model is returned.
 *
 * @example
 * ```ts
-* const value = column_getFacetedRowModel(column)
+* const rows = column_getFacetedRowModel(column, table)
 * ```
 */
 function column_getFacetedRowModel(column, table) {
@@ -29,13 +32,14 @@ function column_getFacetedRowModel(column, table) {
 	return (((_table$options$_rowMo3 = table.options._rowModels) === null || _table$options$_rowMo3 === void 0 || (_table$options$_rowMo4 = _table$options$_rowMo3.facetedRowModel) === null || _table$options$_rowMo4 === void 0 ? void 0 : _table$options$_rowMo4.call(_table$options$_rowMo3, table, (column === null || column === void 0 ? void 0 : column.id) ?? "")) ?? (() => table.getPreFilteredRowModel()))();
 }
 /**
-* Returns faceted unique values for a column.
+* Computes unique facet values and their occurrence counts for one column.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* The configured `facetedUniqueValues` row-model factory owns the calculation.
+* If no factory is registered, an empty `Map` is returned.
 *
 * @example
 * ```ts
-* const value = column_getFacetedUniqueValues(column)
+* const values = column_getFacetedUniqueValues(column, table)
 * ```
 */
 function column_getFacetedUniqueValues(column, table) {
@@ -43,13 +47,14 @@ function column_getFacetedUniqueValues(column, table) {
 	return (((_table$options$_rowMo5 = table.options._rowModels) === null || _table$options$_rowMo5 === void 0 || (_table$options$_rowMo6 = _table$options$_rowMo5.facetedUniqueValues) === null || _table$options$_rowMo6 === void 0 ? void 0 : _table$options$_rowMo6.call(_table$options$_rowMo5, table, column.id)) ?? (() => /* @__PURE__ */ new Map()))();
 }
 /**
-* Returns global faceted min max values for the table.
+* Computes min and max numeric facet values for the global filter context.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The global context is requested with the internal `__global__` column id. If
+* no factory is registered, the result is `undefined`.
 *
 * @example
 * ```ts
-* const value = table_getGlobalFacetedMinMaxValues(table)
+* const range = table_getGlobalFacetedMinMaxValues(table)
 * ```
 */
 function table_getGlobalFacetedMinMaxValues(table) {
@@ -57,13 +62,15 @@ function table_getGlobalFacetedMinMaxValues(table) {
 	return (((_table$options$_rowMo7 = table.options._rowModels) === null || _table$options$_rowMo7 === void 0 || (_table$options$_rowMo8 = _table$options$_rowMo7.facetedMinMaxValues) === null || _table$options$_rowMo8 === void 0 ? void 0 : _table$options$_rowMo8.call(_table$options$_rowMo7, table, "__global__")) ?? (() => void 0))();
 }
 /**
-* Returns global faceted row model for the table.
+* Computes the row model used to derive global facet values.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The global context is requested with the internal `__global__` column id. If
+* no faceted row-model factory is registered, the pre-filtered row model is
+* returned.
 *
 * @example
 * ```ts
-* const value = table_getGlobalFacetedRowModel(table)
+* const rows = table_getGlobalFacetedRowModel(table)
 * ```
 */
 function table_getGlobalFacetedRowModel(table) {
@@ -71,13 +78,14 @@ function table_getGlobalFacetedRowModel(table) {
 	return (((_table$options$_rowMo9 = table.options._rowModels) === null || _table$options$_rowMo9 === void 0 || (_table$options$_rowMo10 = _table$options$_rowMo9.facetedRowModel) === null || _table$options$_rowMo10 === void 0 ? void 0 : _table$options$_rowMo10.call(_table$options$_rowMo9, table, "__global__")) ?? (() => table.getPreFilteredRowModel()))();
 }
 /**
-* Returns global faceted unique values for the table.
+* Computes unique values and occurrence counts for the global filter context.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The global context is requested with the internal `__global__` column id. If
+* no factory is registered, an empty `Map` is returned.
 *
 * @example
 * ```ts
-* const value = table_getGlobalFacetedUniqueValues(table)
+* const values = table_getGlobalFacetedUniqueValues(table)
 * ```
 */
 function table_getGlobalFacetedUniqueValues(table) {

package/dist/features/column-faceting/columnFacetingFeature.utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"columnFacetingFeature.utils.cjs","names":[],"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\n/**\n * Returns faceted min max values for a column.\n *\n * This derives the value from the column definition, table options, and the feature state atoms registered on the table.\n *\n * @example\n * ```ts\n * const value = column_getFacetedMinMaxValues(column)\n * ```\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\n/**\n * Returns faceted row model for a column.\n *\n * This derives the value from the column definition, table options, and the feature state atoms registered on the table.\n *\n * @example\n * ```ts\n * const value = column_getFacetedRowModel(column)\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\n/**\n * Returns faceted unique values for a column.\n *\n * This derives the value from the column definition, table options, and the feature state atoms registered on the table.\n *\n * @example\n * ```ts\n * const value = column_getFacetedUniqueValues(column)\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\n/**\n * Returns global faceted min max values for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getGlobalFacetedMinMaxValues(table)\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\n/**\n * Returns global faceted row model for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getGlobalFacetedRowModel(table)\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\n/**\n * Returns global faceted unique values for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getGlobalFacetedUniqueValues(table)\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"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,8BAKd,QACA,OAC8B;;CAI9B,kCAFE,MAAM,QAAQ,4GAAY,iIAAsB,OAAO,OAAO,GAAG,YAC1D,UACqB;;;;;;;;;;;;AAahC,SAAgB,0BAKd,QACA,OAC4B;;CAI5B,mCAFE,MAAM,QAAQ,8GAAY,8HAAkB,wDAAO,OAAQ,OAAM,GAAG,YAC7D,MAAM,wBAAwB,IACb;;;;;;;;;;;;AAa5B,SAAgB,8BAKd,QACA,OACkB;;CAIlB,mCAFE,MAAM,QAAQ,8GAAY,kIAAsB,OAAO,OAAO,GAAG,4BAC1D,IAAI,KAAkB,IACD;;;;;;;;;;;;AAahC,SAAgB,mCAGd,OAAuE;;CAIvE,mCAFE,MAAM,QAAQ,8GAAY,kIAAsB,OAAO,aAAa,YAC7D,UACqB;;;;;;;;;;;;AAahC,SAAgB,+BAGd,OAAqE;;CAIrE,mCAFE,MAAM,QAAQ,+GAAY,gIAAkB,OAAO,aAAa,YACzD,MAAM,wBAAwB,IACb;;;;;;;;;;;;AAa5B,SAAgB,mCAGd,OAA2D;;CAI3D,oCAFE,MAAM,QAAQ,iHAAY,qIAAsB,OAAO,aAAa,4BAC7D,IAAI,KAAK,IACY"}
+{"version":3,"file":"columnFacetingFeature.utils.cjs","names":[],"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\n/**\n * Computes min and max numeric facet values for one column.\n *\n * The configured `facetedMinMaxValues` row-model factory owns the calculation.\n * If no factory is registered, the result is `undefined`.\n *\n * @example\n * ```ts\n * const range = column_getFacetedMinMaxValues(column, table)\n * ```\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\n/**\n * Computes the row model used to derive one column's facet values.\n *\n * The faceted row model normally applies every other active filter while\n * excluding this column's own filter. If no factory is registered, the\n * pre-filtered row model is returned.\n *\n * @example\n * ```ts\n * const rows = column_getFacetedRowModel(column, table)\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\n/**\n * Computes unique facet values and their occurrence counts for one column.\n *\n * The configured `facetedUniqueValues` row-model factory owns the calculation.\n * If no factory is registered, an empty `Map` is returned.\n *\n * @example\n * ```ts\n * const values = column_getFacetedUniqueValues(column, table)\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\n/**\n * Computes min and max numeric facet values for the global filter context.\n *\n * The global context is requested with the internal `__global__` column id. If\n * no factory is registered, the result is `undefined`.\n *\n * @example\n * ```ts\n * const range = table_getGlobalFacetedMinMaxValues(table)\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\n/**\n * Computes the row model used to derive global facet values.\n *\n * The global context is requested with the internal `__global__` column id. If\n * no faceted row-model factory is registered, the pre-filtered row model is\n * returned.\n *\n * @example\n * ```ts\n * const rows = table_getGlobalFacetedRowModel(table)\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\n/**\n * Computes unique values and occurrence counts for the global filter context.\n *\n * The global context is requested with the internal `__global__` column id. If\n * no factory is registered, an empty `Map` is returned.\n *\n * @example\n * ```ts\n * const values = table_getGlobalFacetedUniqueValues(table)\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"],"mappings":";;;;;;;;;;;;;AAiBA,SAAgB,8BAKd,QACA,OAC8B;;CAI9B,kCAFE,MAAM,QAAQ,4GAAY,iIAAsB,OAAO,OAAO,GAAG,YAC1D,UACqB;;;;;;;;;;;;;;AAehC,SAAgB,0BAKd,QACA,OAC4B;;CAI5B,mCAFE,MAAM,QAAQ,8GAAY,8HAAkB,wDAAO,OAAQ,OAAM,GAAG,YAC7D,MAAM,wBAAwB,IACb;;;;;;;;;;;;;AAc5B,SAAgB,8BAKd,QACA,OACkB;;CAIlB,mCAFE,MAAM,QAAQ,8GAAY,kIAAsB,OAAO,OAAO,GAAG,4BAC1D,IAAI,KAAkB,IACD;;;;;;;;;;;;;AAchC,SAAgB,mCAGd,OAAuE;;CAIvE,mCAFE,MAAM,QAAQ,8GAAY,kIAAsB,OAAO,aAAa,YAC7D,UACqB;;;;;;;;;;;;;;AAehC,SAAgB,+BAGd,OAAqE;;CAIrE,mCAFE,MAAM,QAAQ,+GAAY,gIAAkB,OAAO,aAAa,YACzD,MAAM,wBAAwB,IACb;;;;;;;;;;;;;AAc5B,SAAgB,mCAGd,OAA2D;;CAI3D,oCAFE,MAAM,QAAQ,iHAAY,qIAAsB,OAAO,aAAa,4BAC7D,IAAI,KAAK,IACY"}

package/dist/features/column-faceting/columnFacetingFeature.utils.d.cts

@@ -6,68 +6,76 @@ import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.cjs";
 
 //#region src/features/column-faceting/columnFacetingFeature.utils.d.ts
 /**
- * Returns faceted min max values for a column.
+ * Computes min and max numeric facet values for one column.
  *
- * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ * The configured `facetedMinMaxValues` row-model factory owns the calculation.
+ * If no factory is registered, the result is `undefined`.
  *
  * @example
  * ```ts
- * const value = column_getFacetedMinMaxValues(column)
+ * const range = column_getFacetedMinMaxValues(column, table)
  * ```
  */
 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;
 /**
- * Returns faceted row model for a column.
+ * Computes the row model used to derive one column's facet values.
  *
- * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ * The faceted row model normally applies every other active filter while
+ * excluding this column's own filter. If no factory is registered, the
+ * pre-filtered row model is returned.
  *
  * @example
  * ```ts
- * const value = column_getFacetedRowModel(column)
+ * const rows = column_getFacetedRowModel(column, table)
  * ```
  */
 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>;
 /**
- * Returns faceted unique values for a column.
+ * Computes unique facet values and their occurrence counts for one column.
  *
- * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ * The configured `facetedUniqueValues` row-model factory owns the calculation.
+ * If no factory is registered, an empty `Map` is returned.
  *
  * @example
  * ```ts
- * const value = column_getFacetedUniqueValues(column)
+ * const values = column_getFacetedUniqueValues(column, table)
  * ```
  */
 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>;
 /**
- * Returns global faceted min max values for the table.
+ * Computes min and max numeric facet values for the global filter context.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * The global context is requested with the internal `__global__` column id. If
+ * no factory is registered, the result is `undefined`.
  *
  * @example
  * ```ts
- * const value = table_getGlobalFacetedMinMaxValues(table)
+ * const range = table_getGlobalFacetedMinMaxValues(table)
  * ```
  */
 declare function table_getGlobalFacetedMinMaxValues<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): undefined | [number, number];
 /**
- * Returns global faceted row model for the table.
+ * Computes the row model used to derive global facet values.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * The global context is requested with the internal `__global__` column id. If
+ * no faceted row-model factory is registered, the pre-filtered row model is
+ * returned.
  *
  * @example
  * ```ts
- * const value = table_getGlobalFacetedRowModel(table)
+ * const rows = table_getGlobalFacetedRowModel(table)
  * ```
  */
 declare function table_getGlobalFacetedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
 /**
- * Returns global faceted unique values for the table.
+ * Computes unique values and occurrence counts for the global filter context.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * The global context is requested with the internal `__global__` column id. If
+ * no factory is registered, an empty `Map` is returned.
  *
  * @example
  * ```ts
- * const value = table_getGlobalFacetedUniqueValues(table)
+ * const values = table_getGlobalFacetedUniqueValues(table)
  * ```
  */
 declare function table_getGlobalFacetedUniqueValues<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Map<any, number>;

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

@@ -6,68 +6,76 @@ import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
 
 //#region src/features/column-faceting/columnFacetingFeature.utils.d.ts
 /**
- * Returns faceted min max values for a column.
+ * Computes min and max numeric facet values for one column.
  *
- * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ * The configured `facetedMinMaxValues` row-model factory owns the calculation.
+ * If no factory is registered, the result is `undefined`.
  *
  * @example
  * ```ts
- * const value = column_getFacetedMinMaxValues(column)
+ * const range = column_getFacetedMinMaxValues(column, table)
  * ```
  */
 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;
 /**
- * Returns faceted row model for a column.
+ * Computes the row model used to derive one column's facet values.
  *
- * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ * The faceted row model normally applies every other active filter while
+ * excluding this column's own filter. If no factory is registered, the
+ * pre-filtered row model is returned.
  *
  * @example
  * ```ts
- * const value = column_getFacetedRowModel(column)
+ * const rows = column_getFacetedRowModel(column, table)
  * ```
  */
 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>;
 /**
- * Returns faceted unique values for a column.
+ * Computes unique facet values and their occurrence counts for one column.
  *
- * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ * The configured `facetedUniqueValues` row-model factory owns the calculation.
+ * If no factory is registered, an empty `Map` is returned.
  *
  * @example
  * ```ts
- * const value = column_getFacetedUniqueValues(column)
+ * const values = column_getFacetedUniqueValues(column, table)
  * ```
  */
 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>;
 /**
- * Returns global faceted min max values for the table.
+ * Computes min and max numeric facet values for the global filter context.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * The global context is requested with the internal `__global__` column id. If
+ * no factory is registered, the result is `undefined`.
  *
  * @example
  * ```ts
- * const value = table_getGlobalFacetedMinMaxValues(table)
+ * const range = table_getGlobalFacetedMinMaxValues(table)
  * ```
  */
 declare function table_getGlobalFacetedMinMaxValues<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): undefined | [number, number];
 /**
- * Returns global faceted row model for the table.
+ * Computes the row model used to derive global facet values.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * The global context is requested with the internal `__global__` column id. If
+ * no faceted row-model factory is registered, the pre-filtered row model is
+ * returned.
  *
  * @example
  * ```ts
- * const value = table_getGlobalFacetedRowModel(table)
+ * const rows = table_getGlobalFacetedRowModel(table)
  * ```
  */
 declare function table_getGlobalFacetedRowModel<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData>;
 /**
- * Returns global faceted unique values for the table.
+ * Computes unique values and occurrence counts for the global filter context.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * The global context is requested with the internal `__global__` column id. If
+ * no factory is registered, an empty `Map` is returned.
  *
  * @example
  * ```ts
- * const value = table_getGlobalFacetedUniqueValues(table)
+ * const values = table_getGlobalFacetedUniqueValues(table)
  * ```
  */
 declare function table_getGlobalFacetedUniqueValues<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Map<any, number>;

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

@@ -1,12 +1,13 @@
 //#region src/features/column-faceting/columnFacetingFeature.utils.ts
 /**
-* Returns faceted min max values for a column.
+* Computes min and max numeric facet values for one column.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* The configured `facetedMinMaxValues` row-model factory owns the calculation.
+* If no factory is registered, the result is `undefined`.
 *
 * @example
 * ```ts
-* const value = column_getFacetedMinMaxValues(column)
+* const range = column_getFacetedMinMaxValues(column, table)
 * ```
 */
 function column_getFacetedMinMaxValues(column, table) {
@@ -14,13 +15,15 @@ function column_getFacetedMinMaxValues(column, table) {
 	return (((_table$options$_rowMo = table.options._rowModels) === null || _table$options$_rowMo === void 0 || (_table$options$_rowMo2 = _table$options$_rowMo.facetedMinMaxValues) === null || _table$options$_rowMo2 === void 0 ? void 0 : _table$options$_rowMo2.call(_table$options$_rowMo, table, column.id)) ?? (() => void 0))();
 }
 /**
-* Returns faceted row model for a column.
+* Computes the row model used to derive one column's facet values.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* The faceted row model normally applies every other active filter while
+* excluding this column's own filter. If no factory is registered, the
+* pre-filtered row model is returned.
 *
 * @example
 * ```ts
-* const value = column_getFacetedRowModel(column)
+* const rows = column_getFacetedRowModel(column, table)
 * ```
 */
 function column_getFacetedRowModel(column, table) {
@@ -28,13 +31,14 @@ function column_getFacetedRowModel(column, table) {
 	return (((_table$options$_rowMo3 = table.options._rowModels) === null || _table$options$_rowMo3 === void 0 || (_table$options$_rowMo4 = _table$options$_rowMo3.facetedRowModel) === null || _table$options$_rowMo4 === void 0 ? void 0 : _table$options$_rowMo4.call(_table$options$_rowMo3, table, (column === null || column === void 0 ? void 0 : column.id) ?? "")) ?? (() => table.getPreFilteredRowModel()))();
 }
 /**
-* Returns faceted unique values for a column.
+* Computes unique facet values and their occurrence counts for one column.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* The configured `facetedUniqueValues` row-model factory owns the calculation.
+* If no factory is registered, an empty `Map` is returned.
 *
 * @example
 * ```ts
-* const value = column_getFacetedUniqueValues(column)
+* const values = column_getFacetedUniqueValues(column, table)
 * ```
 */
 function column_getFacetedUniqueValues(column, table) {
@@ -42,13 +46,14 @@ function column_getFacetedUniqueValues(column, table) {
 	return (((_table$options$_rowMo5 = table.options._rowModels) === null || _table$options$_rowMo5 === void 0 || (_table$options$_rowMo6 = _table$options$_rowMo5.facetedUniqueValues) === null || _table$options$_rowMo6 === void 0 ? void 0 : _table$options$_rowMo6.call(_table$options$_rowMo5, table, column.id)) ?? (() => /* @__PURE__ */ new Map()))();
 }
 /**
-* Returns global faceted min max values for the table.
+* Computes min and max numeric facet values for the global filter context.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The global context is requested with the internal `__global__` column id. If
+* no factory is registered, the result is `undefined`.
 *
 * @example
 * ```ts
-* const value = table_getGlobalFacetedMinMaxValues(table)
+* const range = table_getGlobalFacetedMinMaxValues(table)
 * ```
 */
 function table_getGlobalFacetedMinMaxValues(table) {
@@ -56,13 +61,15 @@ function table_getGlobalFacetedMinMaxValues(table) {
 	return (((_table$options$_rowMo7 = table.options._rowModels) === null || _table$options$_rowMo7 === void 0 || (_table$options$_rowMo8 = _table$options$_rowMo7.facetedMinMaxValues) === null || _table$options$_rowMo8 === void 0 ? void 0 : _table$options$_rowMo8.call(_table$options$_rowMo7, table, "__global__")) ?? (() => void 0))();
 }
 /**
-* Returns global faceted row model for the table.
+* Computes the row model used to derive global facet values.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The global context is requested with the internal `__global__` column id. If
+* no faceted row-model factory is registered, the pre-filtered row model is
+* returned.
 *
 * @example
 * ```ts
-* const value = table_getGlobalFacetedRowModel(table)
+* const rows = table_getGlobalFacetedRowModel(table)
 * ```
 */
 function table_getGlobalFacetedRowModel(table) {
@@ -70,13 +77,14 @@ function table_getGlobalFacetedRowModel(table) {
 	return (((_table$options$_rowMo9 = table.options._rowModels) === null || _table$options$_rowMo9 === void 0 || (_table$options$_rowMo10 = _table$options$_rowMo9.facetedRowModel) === null || _table$options$_rowMo10 === void 0 ? void 0 : _table$options$_rowMo10.call(_table$options$_rowMo9, table, "__global__")) ?? (() => table.getPreFilteredRowModel()))();
 }
 /**
-* Returns global faceted unique values for the table.
+* Computes unique values and occurrence counts for the global filter context.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The global context is requested with the internal `__global__` column id. If
+* no factory is registered, an empty `Map` is returned.
 *
 * @example
 * ```ts
-* const value = table_getGlobalFacetedUniqueValues(table)
+* const values = table_getGlobalFacetedUniqueValues(table)
 * ```
 */
 function table_getGlobalFacetedUniqueValues(table) {

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

@@ -1 +1 @@
-{"version":3,"file":"columnFacetingFeature.utils.js","names":[],"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\n/**\n * Returns faceted min max values for a column.\n *\n * This derives the value from the column definition, table options, and the feature state atoms registered on the table.\n *\n * @example\n * ```ts\n * const value = column_getFacetedMinMaxValues(column)\n * ```\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\n/**\n * Returns faceted row model for a column.\n *\n * This derives the value from the column definition, table options, and the feature state atoms registered on the table.\n *\n * @example\n * ```ts\n * const value = column_getFacetedRowModel(column)\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\n/**\n * Returns faceted unique values for a column.\n *\n * This derives the value from the column definition, table options, and the feature state atoms registered on the table.\n *\n * @example\n * ```ts\n * const value = column_getFacetedUniqueValues(column)\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\n/**\n * Returns global faceted min max values for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getGlobalFacetedMinMaxValues(table)\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\n/**\n * Returns global faceted row model for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getGlobalFacetedRowModel(table)\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\n/**\n * Returns global faceted unique values for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getGlobalFacetedUniqueValues(table)\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"],"mappings":";;;;;;;;;;;AAgBA,SAAgB,8BAKd,QACA,OAC8B;;CAI9B,kCAFE,MAAM,QAAQ,4GAAY,iIAAsB,OAAO,OAAO,GAAG,YAC1D,UACqB;;;;;;;;;;;;AAahC,SAAgB,0BAKd,QACA,OAC4B;;CAI5B,mCAFE,MAAM,QAAQ,8GAAY,8HAAkB,wDAAO,OAAQ,OAAM,GAAG,YAC7D,MAAM,wBAAwB,IACb;;;;;;;;;;;;AAa5B,SAAgB,8BAKd,QACA,OACkB;;CAIlB,mCAFE,MAAM,QAAQ,8GAAY,kIAAsB,OAAO,OAAO,GAAG,4BAC1D,IAAI,KAAkB,IACD;;;;;;;;;;;;AAahC,SAAgB,mCAGd,OAAuE;;CAIvE,mCAFE,MAAM,QAAQ,8GAAY,kIAAsB,OAAO,aAAa,YAC7D,UACqB;;;;;;;;;;;;AAahC,SAAgB,+BAGd,OAAqE;;CAIrE,mCAFE,MAAM,QAAQ,+GAAY,gIAAkB,OAAO,aAAa,YACzD,MAAM,wBAAwB,IACb;;;;;;;;;;;;AAa5B,SAAgB,mCAGd,OAA2D;;CAI3D,oCAFE,MAAM,QAAQ,iHAAY,qIAAsB,OAAO,aAAa,4BAC7D,IAAI,KAAK,IACY"}
+{"version":3,"file":"columnFacetingFeature.utils.js","names":[],"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\n/**\n * Computes min and max numeric facet values for one column.\n *\n * The configured `facetedMinMaxValues` row-model factory owns the calculation.\n * If no factory is registered, the result is `undefined`.\n *\n * @example\n * ```ts\n * const range = column_getFacetedMinMaxValues(column, table)\n * ```\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\n/**\n * Computes the row model used to derive one column's facet values.\n *\n * The faceted row model normally applies every other active filter while\n * excluding this column's own filter. If no factory is registered, the\n * pre-filtered row model is returned.\n *\n * @example\n * ```ts\n * const rows = column_getFacetedRowModel(column, table)\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\n/**\n * Computes unique facet values and their occurrence counts for one column.\n *\n * The configured `facetedUniqueValues` row-model factory owns the calculation.\n * If no factory is registered, an empty `Map` is returned.\n *\n * @example\n * ```ts\n * const values = column_getFacetedUniqueValues(column, table)\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\n/**\n * Computes min and max numeric facet values for the global filter context.\n *\n * The global context is requested with the internal `__global__` column id. If\n * no factory is registered, the result is `undefined`.\n *\n * @example\n * ```ts\n * const range = table_getGlobalFacetedMinMaxValues(table)\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\n/**\n * Computes the row model used to derive global facet values.\n *\n * The global context is requested with the internal `__global__` column id. If\n * no faceted row-model factory is registered, the pre-filtered row model is\n * returned.\n *\n * @example\n * ```ts\n * const rows = table_getGlobalFacetedRowModel(table)\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\n/**\n * Computes unique values and occurrence counts for the global filter context.\n *\n * The global context is requested with the internal `__global__` column id. If\n * no factory is registered, an empty `Map` is returned.\n *\n * @example\n * ```ts\n * const values = table_getGlobalFacetedUniqueValues(table)\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"],"mappings":";;;;;;;;;;;;AAiBA,SAAgB,8BAKd,QACA,OAC8B;;CAI9B,kCAFE,MAAM,QAAQ,4GAAY,iIAAsB,OAAO,OAAO,GAAG,YAC1D,UACqB;;;;;;;;;;;;;;AAehC,SAAgB,0BAKd,QACA,OAC4B;;CAI5B,mCAFE,MAAM,QAAQ,8GAAY,8HAAkB,wDAAO,OAAQ,OAAM,GAAG,YAC7D,MAAM,wBAAwB,IACb;;;;;;;;;;;;;AAc5B,SAAgB,8BAKd,QACA,OACkB;;CAIlB,mCAFE,MAAM,QAAQ,8GAAY,kIAAsB,OAAO,OAAO,GAAG,4BAC1D,IAAI,KAAkB,IACD;;;;;;;;;;;;;AAchC,SAAgB,mCAGd,OAAuE;;CAIvE,mCAFE,MAAM,QAAQ,8GAAY,kIAAsB,OAAO,aAAa,YAC7D,UACqB;;;;;;;;;;;;;;AAehC,SAAgB,+BAGd,OAAqE;;CAIrE,mCAFE,MAAM,QAAQ,+GAAY,gIAAkB,OAAO,aAAa,YACzD,MAAM,wBAAwB,IACb;;;;;;;;;;;;;AAc5B,SAAgB,mCAGd,OAA2D;;CAI3D,oCAFE,MAAM,QAAQ,iHAAY,qIAAsB,OAAO,aAAa,4BAC7D,IAAI,KAAK,IACY"}

package/dist/features/column-faceting/createFacetedMinMaxValues.cjs

@@ -25,14 +25,17 @@ function createFacetedMinMaxValues() {
 }
 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) {
+	let facetedMinValue = Number.POSITIVE_INFINITY;
+	let facetedMaxValue = Number.NEGATIVE_INFINITY;
+	let foundAny = false;
+	for (let i = 0; i < flatRows.length; i++) {
+		const value = Number(flatRows[i].getValue(columnId));
+		if (Number.isNaN(value)) continue;
+		foundAny = true;
 		if (value < facetedMinValue) facetedMinValue = value;
 		if (value > facetedMaxValue) facetedMaxValue = value;
 	}
+	if (!foundAny) return void 0;
 	return [facetedMinValue, facetedMaxValue];
 }
 

package/dist/features/column-faceting/createFacetedMinMaxValues.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createFacetedMinMaxValues.cjs","names":["tableMemo","callMemoOrStaticFn","column_getFacetedRowModel"],"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\n/**\n * Creates a memoized faceted min max values helper for faceted filtering.\n *\n * The returned function derives facet data from the table row model and relevant filter state so filter UIs can display available values.\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_Internal<TFeatures, TData> = _table\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"],"mappings":";;;;;;;;;AAYA,SAAgB,4BAMwB;CACtC,QAAQ,QAAQ,aAAa;EAC3B,MAAM,QAA0C;EAChD,OAAOA,wBAAU;GACf,SAAS;GACT,KAAK,aAAa,2BAA2B,UAAU,SAAS;GAChE,QAAQ;GACR,gBAAgB;IACd,MAAM,SAAS,MAAM,UAAU,SAAS;IACxC,IAAI,CAAC,QAAQ,OAAO,CAAC,MAAM,wBAAwB,CAAC,SAAS;IAC7D,OAAO,CACLC,iCACE,QACA,sBACAC,+DACA,MACD,CAAC,SACH;;GAEH;GACD,CAAC;;;AAIN,SAAS,2BAIP,UACA,UAC8B;CAC9B,IAAI,CAAC,SAAS,QAAQ,OAAO;CAE7B,MAAM,gBAAgB,SACnB,KAAK,YAAY,QAAQ,SAAS,SAAS,CAAC,CAC5C,IAAI,OAAO,CACX,QAAQ,UAAU,CAAC,OAAO,MAAM,MAAM,CAAC;CAE1C,IAAI,CAAC,cAAc,QAAQ,OAAO;CAElC,IAAI,kBAAkB,cAAc;CACpC,IAAI,kBAAkB,cAAc;CAEpC,KAAK,MAAM,SAAS,eAAe;EACjC,IAAI,QAAQ,iBAAiB,kBAAkB;EAC/C,IAAI,QAAQ,iBAAiB,kBAAkB;;CAGjD,OAAO,CAAC,iBAAiB,gBAAgB"}
+{"version":3,"file":"createFacetedMinMaxValues.cjs","names":["tableMemo","callMemoOrStaticFn","column_getFacetedRowModel"],"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\n/**\n * Creates a memoized faceted min max values helper for faceted filtering.\n *\n * The returned function derives facet data from the table row model and relevant filter state so filter UIs can display available values.\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_Internal<TFeatures, TData> = _table\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  let facetedMinValue = Number.POSITIVE_INFINITY\n  let facetedMaxValue = Number.NEGATIVE_INFINITY\n  let foundAny = false\n\n  for (let i = 0; i < flatRows.length; i++) {\n    const value = Number(flatRows[i]!.getValue(columnId))\n    if (Number.isNaN(value)) continue\n    foundAny = true\n    if (value < facetedMinValue) facetedMinValue = value\n    if (value > facetedMaxValue) facetedMaxValue = value\n  }\n\n  if (!foundAny) return undefined\n  return [facetedMinValue, facetedMaxValue]\n}\n"],"mappings":";;;;;;;;;AAYA,SAAgB,4BAMwB;CACtC,QAAQ,QAAQ,aAAa;EAC3B,MAAM,QAA0C;EAChD,OAAOA,wBAAU;GACf,SAAS;GACT,KAAK,aAAa,2BAA2B,UAAU,SAAS;GAChE,QAAQ;GACR,gBAAgB;IACd,MAAM,SAAS,MAAM,UAAU,SAAS;IACxC,IAAI,CAAC,QAAQ,OAAO,CAAC,MAAM,wBAAwB,CAAC,SAAS;IAC7D,OAAO,CACLC,iCACE,QACA,sBACAC,+DACA,MACD,CAAC,SACH;;GAEH;GACD,CAAC;;;AAIN,SAAS,2BAIP,UACA,UAC8B;CAC9B,IAAI,CAAC,SAAS,QAAQ,OAAO;CAE7B,IAAI,kBAAkB,OAAO;CAC7B,IAAI,kBAAkB,OAAO;CAC7B,IAAI,WAAW;CAEf,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;EACxC,MAAM,QAAQ,OAAO,SAAS,GAAI,SAAS,SAAS,CAAC;EACrD,IAAI,OAAO,MAAM,MAAM,EAAE;EACzB,WAAW;EACX,IAAI,QAAQ,iBAAiB,kBAAkB;EAC/C,IAAI,QAAQ,iBAAiB,kBAAkB;;CAGjD,IAAI,CAAC,UAAU,OAAO;CACtB,OAAO,CAAC,iBAAiB,gBAAgB"}

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

@@ -25,14 +25,17 @@ function createFacetedMinMaxValues() {
 }
 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) {
+	let facetedMinValue = Number.POSITIVE_INFINITY;
+	let facetedMaxValue = Number.NEGATIVE_INFINITY;
+	let foundAny = false;
+	for (let i = 0; i < flatRows.length; i++) {
+		const value = Number(flatRows[i].getValue(columnId));
+		if (Number.isNaN(value)) continue;
+		foundAny = true;
 		if (value < facetedMinValue) facetedMinValue = value;
 		if (value > facetedMaxValue) facetedMaxValue = value;
 	}
+	if (!foundAny) return void 0;
 	return [facetedMinValue, facetedMaxValue];
 }