@tanstack/table-core 8.0.0-alpha.63 → 8.0.0-alpha.67

package/src/features/Filters.ts

@@ -7,6 +7,7 @@ import {
   TableInstance,
   Row,
   Updater,
+  TableFeature,
 } from '../types'
 import {
   functionalUpdate,
@@ -15,6 +16,7 @@ import {
   memo,
   Overwrite,
 } from '../utils'
+import { filterRows } from '../utils/filterRowsUtils'
 
 export type FiltersTableState = {
   columnFilters: ColumnFiltersState
@@ -30,17 +32,25 @@ export type ColumnFilter = {
   value: unknown
 }
 
-/*
-A filter function is any function that takes an array of rows and returns an array of rows. Because filter functions can be used for both column and global filters, they are passed an array of columnIds to filter on. 
-*/
+export type ResolvedColumnFilter<TGenerics extends TableGenerics> = {
+  id: string
+  resolvedValue: unknown
+  filterFn: FilterFn<TGenerics>
+}
 
 export type FilterFn<TGenerics extends TableGenerics> = {
-  (rows: Row<TGenerics>[], columnIds: string[], filterValue: any): any
+  (row: Row<TGenerics>, columnId: string, filterValue: any): boolean
+  resolveFilterValue?: TransformFilterValueFn<TGenerics>
   autoRemove?: ColumnFilterAutoRemoveTestFn<TGenerics>
 }
 
+export type TransformFilterValueFn<TGenerics extends TableGenerics> = (
+  value: any,
+  column?: Column<TGenerics>
+) => unknown
+
 export type ColumnFilterAutoRemoveTestFn<TGenerics extends TableGenerics> = (
-  value: unknown,
+  value: any,
   column?: Column<TGenerics>
 ) => boolean
 
@@ -57,82 +67,75 @@ export type FilterFnOption<TGenerics extends TableGenerics> =
 
 export type FiltersColumnDef<TGenerics extends TableGenerics> = {
   filterFn?: FilterFnOption<Overwrite<TGenerics, { Value: any }>>
-  enableAllFilters?: boolean
   enableColumnFilter?: boolean
   enableGlobalFilter?: boolean
-  defaultCanFilter?: boolean
-  defaultCanColumnFilter?: boolean
-  defaultCanGlobalFilter?: boolean
+  enableFaceting?: boolean
 }
 
 export type FiltersColumn<TGenerics extends TableGenerics> = {
   filterFn: FilterFnOption<Overwrite<TGenerics, { Value: any }>>
-  getCanColumnFilter: () => boolean
+  getAutoFilterFn: () => FilterFn<TGenerics> | undefined
+  getFilterFn: () => FilterFn<TGenerics> | undefined
+  setFilterValue: (updater: Updater<any>) => void
+  getCanFilter: () => boolean
   getCanGlobalFilter: () => boolean
-  getColumnFilterIndex: () => number
-  getColumnIsFiltered: () => boolean
-  getColumnFilterValue: () => unknown
-  setColumnFilterValue: (updater: Updater<any>) => void
-  getPreFilteredRows: () => Row<TGenerics>[] | undefined
-  getPreFilteredUniqueValues: () => Map<any, number>
-  getPreFilteredMinMaxValues: () => [any, any]
+  getFacetedRowModel: () => RowModel<TGenerics>
+  getIsFiltered: () => boolean
+  getFilterValue: () => unknown
+  getFilterIndex: () => number
+  getFacetedUniqueValues: () => Map<any, number>
+  getFacetedMinMaxValues: () => [any, any]
+}
+
+export type FiltersRow<TGenerics extends TableGenerics> = {
+  columnFilterMap: Record<string, boolean>
+  subRowsByFacetId: Record<string, Row<TGenerics>[]>
 }
 
 export type FiltersOptions<TGenerics extends TableGenerics> = {
+  enableFilters?: boolean
+  manualFiltering?: boolean
   filterFromLeafRows?: boolean
   filterFns?: TGenerics['FilterFns']
-  enableFilters?: boolean
+
   // Column
-  manualColumnFiltering?: boolean
   onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>
   enableColumnFilters?: boolean
-  getColumnFilteredRowModel?: (
+  getFilteredRowModel?: (
     instance: TableInstance<TGenerics>
   ) => () => RowModel<TGenerics>
+
   // Global
-  manualGlobalFiltering?: boolean
   globalFilterFn?: FilterFnOption<TGenerics>
   onGlobalFilterChange?: OnChangeFn<any>
   enableGlobalFilter?: boolean
-  getGlobalFilteredRowModel?: (
-    instance: TableInstance<TGenerics>
-  ) => () => RowModel<TGenerics>
-  getColumnCanGlobalFilterFn?: (column: Column<TGenerics>) => boolean
+  getColumnCanGlobalFilter?: (column: Column<TGenerics>) => boolean
 }
 
 export type FiltersInstance<TGenerics extends TableGenerics> = {
-  getColumnAutoFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined
-
-  getColumnFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined
-
   setColumnFilters: (updater: Updater<ColumnFiltersState>) => void
-  setColumnFilterValue: (columnId: string, updater: Updater<any>) => void
-  resetColumnFilters: () => void
-  getColumnCanColumnFilter: (columnId: string) => boolean
 
-  getColumnIsFiltered: (columnId: string) => boolean
-  getColumnFilterValue: (columnId: string) => unknown
-  getColumnFilterIndex: (columnId: string) => number
+  resetColumnFilters: () => void
 
   // Column Filters
-  getPreColumnFilteredRowModel: () => RowModel<TGenerics>
-  getColumnFilteredRowModel: () => RowModel<TGenerics>
-  _getColumnFilteredRowModel?: () => RowModel<TGenerics>
+  getPreFilteredRowModel: () => RowModel<TGenerics>
+  getFilteredRowModel: () => RowModel<TGenerics>
+  _getFilteredRowModel?: () => RowModel<TGenerics>
 
   // Global Filters
   setGlobalFilter: (updater: Updater<any>) => void
   resetGlobalFilter: () => void
   getGlobalAutoFilterFn: () => FilterFn<TGenerics> | undefined
   getGlobalFilterFn: () => FilterFn<TGenerics> | undefined
-  getColumnCanGlobalFilter: (columnId: string) => boolean
-  getPreGlobalFilteredRowModel: () => RowModel<TGenerics>
-  getGlobalFilteredRowModel: () => RowModel<TGenerics>
-  _getGlobalFilteredRowModel?: () => RowModel<TGenerics>
+
+  getGlobalFacetedRowModel: () => RowModel<TGenerics>
+  getGlobalFacetedUniqueValues: () => Map<any, number>
+  getGlobalFacetedMinMaxValues: () => [number, number]
 }
 
 //
 
-export const Filters = {
+export const Filters: TableFeature = {
   getDefaultColumn: <
     TGenerics extends TableGenerics
   >(): FiltersColumnDef<TGenerics> => {
@@ -141,12 +144,13 @@ export const Filters = {
     }
   },
 
-  getInitialState: (): FiltersTableState => {
+  getInitialState: (state): FiltersTableState => {
     return {
       columnFilters: [],
       globalFilter: undefined,
       columnFiltersProgress: 1,
       globalFilterProgress: 1,
+      ...state,
     }
   },
 
@@ -158,7 +162,7 @@ export const Filters = {
       onGlobalFilterChange: makeStateUpdater('globalFilter', instance),
       filterFromLeafRows: true,
       globalFilterFn: 'auto',
-      getColumnCanGlobalFilterFn: column => {
+      getColumnCanGlobalFilter: column => {
         const value = instance
           .getCoreRowModel()
           .flatRows[0]?.getAllCellsByColumnId()[column.id]?.value
@@ -172,76 +176,19 @@ export const Filters = {
     column: Column<TGenerics>,
     instance: TableInstance<TGenerics>
   ): FiltersColumn<TGenerics> => {
-    const getFacetInfo = memo(
-      () => [column.getPreFilteredRows()],
-      (rows = []) => {
-        let preFilteredUniqueValues = new Map<any, number>()
-
-        let preFilteredMinMaxValues: [any, any] = [
-          rows[0]?.values[column.id] ?? null,
-          rows[0]?.values[column.id] ?? null,
-        ]
-
-        for (let i = 0; i < rows.length; i++) {
-          const value = rows[i]?.values[column.id]
-
-          if (preFilteredUniqueValues.has(value)) {
-            preFilteredUniqueValues.set(
-              value,
-              (preFilteredUniqueValues.get(value) ?? 0) + 1
-            )
-          } else {
-            preFilteredUniqueValues.set(value, 1)
-          }
-
-          if (value < preFilteredMinMaxValues[0]) {
-            preFilteredMinMaxValues[0] = value
-          } else if (value > preFilteredMinMaxValues[1]) {
-            preFilteredMinMaxValues[1] = value
-          }
-        }
-
-        return {
-          preFilteredUniqueValues,
-          preFilteredMinMaxValues,
-        }
-      },
-      {
-        key: 'column.getFacetInfo',
-        debug: () => instance.options.debugAll ?? instance.options.debugColumns,
-      }
-    )
-
     return {
       filterFn: column.filterFn,
-      getCanColumnFilter: () => instance.getColumnCanColumnFilter(column.id),
-      getCanGlobalFilter: () => instance.getColumnCanGlobalFilter(column.id),
-      getColumnFilterIndex: () => instance.getColumnFilterIndex(column.id),
-      getColumnIsFiltered: () => instance.getColumnIsFiltered(column.id),
-      getColumnFilterValue: () => instance.getColumnFilterValue(column.id),
-      setColumnFilterValue: val =>
-        instance.setColumnFilterValue(column.id, val),
-      getPreFilteredUniqueValues: () => getFacetInfo().preFilteredUniqueValues,
-      getPreFilteredMinMaxValues: () => getFacetInfo().preFilteredMinMaxValues,
-      getPreFilteredRows: () => undefined,
-    }
-  },
-
-  createInstance: <TGenerics extends TableGenerics>(
-    instance: TableInstance<TGenerics>
-  ): FiltersInstance<TGenerics> => {
-    return {
-      getColumnAutoFilterFn: columnId => {
+      getAutoFilterFn: () => {
         const firstRow = instance.getCoreRowModel().flatRows[0]
 
-        const value = firstRow?.values[columnId]
+        const value = firstRow?.values[column.id]
 
         if (typeof value === 'string') {
           return filterFns.includesString
         }
 
         if (typeof value === 'number') {
-          return filterFns.betweenNumberRange
+          return filterFns.inNumberRange
         }
 
         if (value !== null && typeof value === 'object') {
@@ -254,21 +201,13 @@ export const Filters = {
 
         return filterFns.weakEquals
       },
-      getGlobalAutoFilterFn: () => {
-        return filterFns.includesString
-      },
-      getColumnFilterFn: columnId => {
-        const column = instance.getColumn(columnId)
+      getFilterFn: () => {
         const userFilterFns = instance.options.filterFns
 
-        if (!column) {
-          throw new Error()
-        }
-
         return isFunction(column.filterFn)
           ? column.filterFn
           : column.filterFn === 'auto'
-          ? instance.getColumnAutoFilterFn(columnId)
+          ? column.getAutoFilterFn()
           : (userFilterFns as Record<string, any>)?.[
               column.filterFn as string
             ] ??
@@ -276,118 +215,38 @@ export const Filters = {
               column.filterFn as BuiltInFilterFn
             ] as FilterFn<TGenerics>)
       },
-
-      getGlobalFilterFn: () => {
-        const { filterFns: userFilterFns, globalFilterFn: globalFilterFn } =
-          instance.options
-
-        return isFunction(globalFilterFn)
-          ? globalFilterFn
-          : globalFilterFn === 'auto'
-          ? instance.getGlobalAutoFilterFn()
-          : (userFilterFns as Record<string, any>)?.[
-              globalFilterFn as string
-            ] ??
-            (filterFns[
-              globalFilterFn as BuiltInFilterFn
-            ] as FilterFn<TGenerics>)
-      },
-
-      setColumnFilters: (updater: Updater<ColumnFiltersState>) => {
-        const leafColumns = instance.getAllLeafColumns()
-
-        const updateFn = (old: ColumnFiltersState) => {
-          return functionalUpdate(updater, old)?.filter(filter => {
-            const column = leafColumns.find(d => d.id === filter.id)
-
-            if (column) {
-              const filterFn = instance.getColumnFilterFn(column.id)
-
-              if (shouldAutoRemoveFilter(filterFn, filter.value, column)) {
-                return false
-              }
-            }
-
-            return true
-          })
-        }
-
-        instance.options.onColumnFiltersChange?.(updateFn)
-      },
-
-      setGlobalFilter: updater => {
-        instance.options.onGlobalFilterChange?.(updater)
-      },
-
-      resetGlobalFilter: () => {
-        instance.setGlobalFilter(instance.initialState.globalFilter)
-      },
-
-      getColumnCanColumnFilter: columnId => {
-        const column = instance.getColumn(columnId)
-
-        if (!column) {
-          throw new Error()
-        }
-
+      getCanFilter: () => {
         return (
-          column.enableAllFilters ??
-          column.enableColumnFilter ??
-          instance.options.enableFilters ??
-          instance.options.enableColumnFilters ??
-          column.defaultCanColumnFilter ??
-          column.defaultCanFilter ??
+          (column.enableColumnFilter ?? true) &&
+          (instance.options.enableColumnFilters ?? true) &&
+          (instance.options.enableFilters ?? true) &&
           !!column.accessorFn
         )
       },
 
-      getColumnCanGlobalFilter: columnId => {
-        const column = instance.getColumn(columnId)
-
-        if (!column) {
-          throw new Error()
-        }
-
+      getCanGlobalFilter: () => {
         return (
-          ((instance.options.enableFilters ??
-            instance.options.enableGlobalFilter ??
-            column.enableAllFilters ??
-            column.enableGlobalFilter ??
-            column.defaultCanGlobalFilter ??
-            column.defaultCanFilter ??
-            !!column.accessorFn) &&
-            instance.options.getColumnCanGlobalFilterFn?.(column)) ??
-          true
+          (column.enableGlobalFilter ?? true) &&
+          (instance.options.enableGlobalFilter ?? true) &&
+          (instance.options.enableFilters ?? true) &&
+          (instance.options.getColumnCanGlobalFilter?.(column) ?? true) &&
+          !!column.accessorFn
         )
       },
 
-      getColumnIsFiltered: columnId =>
-        instance.getColumnFilterIndex(columnId) > -1,
+      getIsFiltered: () => column.getFilterIndex() > -1,
 
-      getColumnFilterValue: columnId =>
-        instance.getState().columnFilters?.find(d => d.id === columnId)?.value,
+      getFilterValue: () =>
+        instance.getState().columnFilters?.find(d => d.id === column.id)?.value,
 
-      getColumnFilterIndex: columnId =>
-        instance.getState().columnFilters?.findIndex(d => d.id === columnId) ??
+      getFilterIndex: () =>
+        instance.getState().columnFilters?.findIndex(d => d.id === column.id) ??
         -1,
 
-      setColumnFilterValue: (columnId, value) => {
-        if (!columnId) return
-
+      setFilterValue: value => {
         instance.setColumnFilters(old => {
-          const column = instance.getColumn(columnId)
-
-          if (!column) {
-            if (process.env.NODE_ENV !== 'production') {
-              console.warn(
-                `Table: Could not find a column with id: ${columnId}`
-              )
-            }
-            throw new Error()
-          }
-
-          const filterFn = instance.getColumnFilterFn(column.id)
-          const previousfilter = old?.find(d => d.id === columnId)
+          const filterFn = column.getFilterFn()
+          const previousfilter = old?.find(d => d.id === column.id)
 
           const newFilter = functionalUpdate(
             value,
@@ -402,15 +261,15 @@ export const Filters = {
               column
             )
           ) {
-            return old?.filter(d => d.id !== columnId) ?? []
+            return old?.filter(d => d.id !== column.id) ?? []
           }
 
-          const newFilterObj = { id: columnId, value: newFilter }
+          const newFilterObj = { id: column.id, value: newFilter }
 
           if (previousfilter) {
             return (
               old?.map(d => {
-                if (d.id === columnId) {
+                if (d.id === column.id) {
                   return newFilterObj
                 }
                 return d
@@ -425,49 +284,199 @@ export const Filters = {
           return [newFilterObj]
         })
       },
+      getFacetedRowModel: memo(
+        () => [
+          instance.getPreFilteredRowModel(),
+          instance.getState().columnFilters,
+          instance.getState().globalFilter,
+          // Include this to force the filtered facet info to be calculated
+          instance.getFilteredRowModel(),
+        ],
+        (rowModel, columnFilters, globalFilter, _) => {
+          if (!columnFilters?.length && !globalFilter) {
+            return rowModel
+          }
 
-      resetColumnFilters: () => {
-        instance.setColumnFilters(instance.initialState?.columnFilters ?? [])
+          return filterRows(
+            rowModel.rows,
+            [
+              ...columnFilters.map(d => d.id).filter(d => d !== column.id),
+              globalFilter ? '__global__' : undefined,
+            ].filter(Boolean) as string[],
+            instance
+          )
+        },
+        {
+          key:
+            process.env.NODE_ENV === 'production' &&
+            'getFacetedRowModel_' + column.id,
+          debug: () =>
+            instance.options.debugAll ?? instance.options.debugColumns,
+        }
+      ),
+      getFacetedUniqueValues: memo(
+        () => [column.getFacetedRowModel()],
+        facetedRowModel => getRowModelUniqueValues(facetedRowModel, column.id),
+        {
+          key:
+            process.env.NODE_ENV === 'production' &&
+            'column.getFacetedUniqueValues',
+          debug: () =>
+            instance.options.debugAll ?? instance.options.debugColumns,
+        }
+      ),
+      getFacetedMinMaxValues: memo(
+        () => [column.getFacetedRowModel()],
+        facetedRowModel => getRowModelMinMaxValues(facetedRowModel, column.id),
+        {
+          key:
+            process.env.NODE_ENV === 'production' &&
+            'column.getFacetedMinMaxValues',
+          debug: () =>
+            instance.options.debugAll ?? instance.options.debugColumns,
+        }
+      ),
+    }
+  },
+
+  createRow: <TGenerics extends TableGenerics>(
+    row: Row<TGenerics>,
+    instance: TableInstance<TGenerics>
+  ): FiltersRow<TGenerics> => {
+    return {
+      columnFilterMap: {},
+      subRowsByFacetId: {},
+    }
+  },
+
+  createInstance: <TGenerics extends TableGenerics>(
+    instance: TableInstance<TGenerics>
+  ): FiltersInstance<TGenerics> => {
+    return {
+      getGlobalAutoFilterFn: () => {
+        return filterFns.includesString
       },
 
-      getPreColumnFilteredRowModel: () => instance.getCoreRowModel(),
-      getColumnFilteredRowModel: () => {
-        if (
-          !instance._getColumnFilteredRowModel &&
-          instance.options.getColumnFilteredRowModel
-        ) {
-          instance._getColumnFilteredRowModel =
-            instance.options.getColumnFilteredRowModel(instance)
-        }
+      getGlobalFilterFn: () => {
+        const { filterFns: userFilterFns, globalFilterFn: globalFilterFn } =
+          instance.options
 
-        if (
-          instance.options.manualColumnFiltering ||
-          !instance._getColumnFilteredRowModel
-        ) {
-          return instance.getPreColumnFilteredRowModel()
+        return isFunction(globalFilterFn)
+          ? globalFilterFn
+          : globalFilterFn === 'auto'
+          ? instance.getGlobalAutoFilterFn()
+          : (userFilterFns as Record<string, any>)?.[
+              globalFilterFn as string
+            ] ??
+            (filterFns[
+              globalFilterFn as BuiltInFilterFn
+            ] as FilterFn<TGenerics>)
+      },
+
+      setColumnFilters: (updater: Updater<ColumnFiltersState>) => {
+        const leafColumns = instance.getAllLeafColumns()
+
+        const updateFn = (old: ColumnFiltersState) => {
+          return functionalUpdate(updater, old)?.filter(filter => {
+            const column = leafColumns.find(d => d.id === filter.id)
+
+            if (column) {
+              const filterFn = column.getFilterFn()
+
+              if (shouldAutoRemoveFilter(filterFn, filter.value, column)) {
+                return false
+              }
+            }
+
+            return true
+          })
         }
 
-        return instance._getColumnFilteredRowModel()
+        instance.options.onColumnFiltersChange?.(updateFn)
+      },
+
+      setGlobalFilter: updater => {
+        instance.options.onGlobalFilterChange?.(updater)
+      },
+
+      resetGlobalFilter: () => {
+        instance.setGlobalFilter(instance.initialState.globalFilter)
+      },
+
+      resetColumnFilters: () => {
+        instance.setColumnFilters(instance.initialState?.columnFilters ?? [])
       },
-      getPreGlobalFilteredRowModel: () => instance.getColumnFilteredRowModel(),
-      getGlobalFilteredRowModel: () => {
+
+      getPreFilteredRowModel: () => instance.getCoreRowModel(),
+      getFilteredRowModel: () => {
         if (
-          !instance._getGlobalFilteredRowModel &&
-          instance.options.getGlobalFilteredRowModel
+          !instance._getFilteredRowModel &&
+          instance.options.getFilteredRowModel
         ) {
-          instance._getGlobalFilteredRowModel =
-            instance.options.getGlobalFilteredRowModel(instance)
+          instance._getFilteredRowModel =
+            instance.options.getFilteredRowModel(instance)
         }
 
         if (
-          instance.options.manualGlobalFiltering ||
-          !instance._getGlobalFilteredRowModel
+          instance.options.manualFiltering ||
+          !instance._getFilteredRowModel
         ) {
-          return instance.getPreGlobalFilteredRowModel()
+          return instance.getPreFilteredRowModel()
         }
 
-        return instance._getGlobalFilteredRowModel()
+        return instance._getFilteredRowModel()
       },
+
+      getGlobalFacetedRowModel: memo(
+        () => [
+          instance.getPreFilteredRowModel(),
+          instance.getState().columnFilters,
+          instance.getState().globalFilter,
+          // Include this to force the filtered facet info to be calculated
+          instance.getFilteredRowModel(),
+        ],
+        (rowModel, columnFilters, globalFilter, _) => {
+          if (!columnFilters?.length && !globalFilter) {
+            return rowModel
+          }
+
+          return filterRows(
+            rowModel.rows,
+            columnFilters.map(d => d.id),
+            instance
+          )
+        },
+        {
+          key:
+            process.env.NODE_ENV === 'production' && 'getGlobalFacetedRowModel',
+          debug: () =>
+            instance.options.debugAll ?? instance.options.debugColumns,
+        }
+      ),
+      getGlobalFacetedUniqueValues: memo(
+        () => [instance.getGlobalFacetedRowModel()],
+        facetedRowModel =>
+          getRowModelUniqueValues(facetedRowModel, '__global__'),
+        {
+          key:
+            process.env.NODE_ENV === 'production' &&
+            'getGlobalFacetedUniqueValues',
+          debug: () =>
+            instance.options.debugAll ?? instance.options.debugColumns,
+        }
+      ),
+      getGlobalFacetedMinMaxValues: memo(
+        () => [instance.getGlobalFacetedRowModel()],
+        facetedRowModel =>
+          getRowModelMinMaxValues(facetedRowModel, '__global__'),
+        {
+          key:
+            process.env.NODE_ENV === 'production' &&
+            'getGlobalFacetedMinMaxValues',
+          debug: () =>
+            instance.options.debugAll ?? instance.options.debugColumns,
+        }
+      ),
     }
   },
 }
@@ -485,3 +494,44 @@ export function shouldAutoRemoveFilter<TGenerics extends TableGenerics>(
     (typeof value === 'string' && !value)
   )
 }
+
+export function getRowModelMinMaxValues<TGenerics extends TableGenerics>(
+  rowModel: RowModel<TGenerics>,
+  columnId: string
+) {
+  let facetedMinMaxValues: [any, any] = [
+    rowModel.flatRows[0]?.values[columnId] ?? null,
+    rowModel.flatRows[0]?.values[columnId] ?? null,
+  ]
+
+  for (let i = 0; i < rowModel.flatRows.length; i++) {
+    const value = rowModel.flatRows[i]?.values[columnId]
+
+    if (value < facetedMinMaxValues[0]) {
+      facetedMinMaxValues[0] = value
+    } else if (value > facetedMinMaxValues[1]) {
+      facetedMinMaxValues[1] = value
+    }
+  }
+
+  return facetedMinMaxValues
+}
+
+export function getRowModelUniqueValues<TGenerics extends TableGenerics>(
+  rowModel: RowModel<TGenerics>,
+  columnId: string
+) {
+  let facetedUniqueValues = new Map<any, number>()
+
+  for (let i = 0; i < rowModel.flatRows.length; i++) {
+    const value = rowModel.flatRows[i]?.values[columnId]
+
+    if (facetedUniqueValues.has(value)) {
+      facetedUniqueValues.set(value, (facetedUniqueValues.get(value) ?? 0) + 1)
+    } else {
+      facetedUniqueValues.set(value, 1)
+    }
+  }
+
+  return facetedUniqueValues
+}