@tanstack/table-core 8.0.0-alpha.65 → 8.0.0-alpha.69

package/src/features/Filters.ts

@@ -16,13 +16,12 @@ import {
   memo,
   Overwrite,
 } from '../utils'
-import { filterRows } from '../utils/filterRowsUtils'
 
 export type FiltersTableState = {
   columnFilters: ColumnFiltersState
   globalFilter: any
-  columnFiltersProgress: number
-  globalFilterProgress: number
+  // filtersProgress: number
+  // facetProgress: Record<string, number>
 }
 
 export type ColumnFiltersState = ColumnFilter[]
@@ -32,6 +31,12 @@ export type ColumnFilter = {
   value: unknown
 }
 
+export type ResolvedColumnFilter<TGenerics extends TableGenerics> = {
+  id: string
+  resolvedValue: unknown
+  filterFn: FilterFn<TGenerics>
+}
+
 export type FilterFn<TGenerics extends TableGenerics> = {
   (row: Row<TGenerics>, columnId: string, filterValue: any): boolean
   resolveFilterValue?: TransformFilterValueFn<TGenerics>
@@ -68,15 +73,20 @@ export type FiltersColumnDef<TGenerics extends TableGenerics> = {
 
 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
   getFacetedRowModel: () => RowModel<TGenerics>
+  _getFacetedRowModel?: () => RowModel<TGenerics>
+  getIsFiltered: () => boolean
+  getFilterValue: () => unknown
+  getFilterIndex: () => number
   getFacetedUniqueValues: () => Map<any, number>
+  _getFacetedUniqueValues?: () => Map<any, number>
   getFacetedMinMaxValues: () => [any, any]
+  _getFacetedMinMaxValues?: () => [any, any]
 }
 
 export type FiltersRow<TGenerics extends TableGenerics> = {
@@ -89,35 +99,39 @@ export type FiltersOptions<TGenerics extends TableGenerics> = {
   manualFiltering?: boolean
   filterFromLeafRows?: boolean
   filterFns?: TGenerics['FilterFns']
+  getFilteredRowModel?: (
+    instance: TableInstance<TGenerics>
+  ) => () => RowModel<TGenerics>
 
   // Column
   onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>
   enableColumnFilters?: boolean
-  getFilteredRowModel?: (
-    instance: TableInstance<TGenerics>
-  ) => () => RowModel<TGenerics>
 
   // Global
   globalFilterFn?: FilterFnOption<TGenerics>
   onGlobalFilterChange?: OnChangeFn<any>
   enableGlobalFilter?: boolean
   getColumnCanGlobalFilter?: (column: Column<TGenerics>) => boolean
+
+  // Faceting
+  getFacetedRowModel?: (
+    instance: TableInstance<TGenerics>,
+    columnId: string
+  ) => () => RowModel<TGenerics>
+  getFacetedUniqueValues?: (
+    instance: TableInstance<TGenerics>,
+    columnId: string
+  ) => () => Map<any, number>
+  getFacetedMinMaxValues?: (
+    instance: TableInstance<TGenerics>,
+    columnId: string
+  ) => () => [number, number]
 }
 
 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
-  getColumnFacetedRowModel: (columnId: string) => RowModel<TGenerics>
 
-  getColumnIsFiltered: (columnId: string) => boolean
-  getColumnFilterValue: (columnId: string) => unknown
-  getColumnFilterIndex: (columnId: string) => number
+  resetColumnFilters: (defaultState?: boolean) => void
 
   // Column Filters
   getPreFilteredRowModel: () => RowModel<TGenerics>
@@ -126,13 +140,15 @@ export type FiltersInstance<TGenerics extends TableGenerics> = {
 
   // Global Filters
   setGlobalFilter: (updater: Updater<any>) => void
-  resetGlobalFilter: () => void
+  resetGlobalFilter: (defaultState?: boolean) => void
   getGlobalAutoFilterFn: () => FilterFn<TGenerics> | undefined
   getGlobalFilterFn: () => FilterFn<TGenerics> | undefined
-  getColumnCanGlobalFilter: (columnId: string) => boolean
   getGlobalFacetedRowModel: () => RowModel<TGenerics>
+  _getGlobalFacetedRowModel?: () => RowModel<TGenerics>
   getGlobalFacetedUniqueValues: () => Map<any, number>
+  _getGlobalFacetedUniqueValues?: () => Map<any, number>
   getGlobalFacetedMinMaxValues: () => [number, number]
+  _getGlobalFacetedMinMaxValues?: () => [number, number]
 }
 
 //
@@ -150,8 +166,8 @@ export const Filters: TableFeature = {
     return {
       columnFilters: [],
       globalFilter: undefined,
-      columnFiltersProgress: 1,
-      globalFilterProgress: 1,
+      // filtersProgress: 1,
+      // facetProgress: {},
       ...state,
     }
   },
@@ -162,12 +178,13 @@ export const Filters: TableFeature = {
     return {
       onColumnFiltersChange: makeStateUpdater('columnFilters', instance),
       onGlobalFilterChange: makeStateUpdater('globalFilter', instance),
-      filterFromLeafRows: true,
+      filterFromLeafRows: false,
       globalFilterFn: 'auto',
       getColumnCanGlobalFilter: column => {
         const value = instance
           .getCoreRowModel()
-          .flatRows[0]?.getAllCellsByColumnId()[column.id]?.value
+          .flatRows[0]?.getAllCellsByColumnId()
+          [column.id]?.getValue()
 
         return typeof value === 'string'
       },
@@ -180,86 +197,10 @@ export const Filters: TableFeature = {
   ): FiltersColumn<TGenerics> => {
     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),
-      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
-          }
-
-          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 {
-      getColumnAutoFilterFn: columnId => {
+      getAutoFilterFn: () => {
         const firstRow = instance.getCoreRowModel().flatRows[0]
 
-        const value = firstRow?.values[columnId]
+        const value = firstRow?.getValue(column.id)
 
         if (typeof value === 'string') {
           return filterFns.includesString
@@ -279,30 +220,13 @@ export const Filters: TableFeature = {
 
         return filterFns.weakEquals
       },
-      getColumnFacetedRowModel: columnId => {
-        const column = instance.getColumn(columnId)
-
-        if (!column) {
-          throw new Error()
-        }
-
-        return column.getFacetedRowModel()
-      },
-      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
             ] ??
@@ -310,60 +234,7 @@ export const Filters: TableFeature = {
               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.enableColumnFilter ?? true) &&
           (instance.options.enableColumnFilters ?? true) &&
@@ -372,13 +243,7 @@ export const Filters: TableFeature = {
         )
       },
 
-      getColumnCanGlobalFilter: columnId => {
-        const column = instance.getColumn(columnId)
-
-        if (!column) {
-          throw new Error()
-        }
-
+      getCanGlobalFilter: () => {
         return (
           (column.enableGlobalFilter ?? true) &&
           (instance.options.enableGlobalFilter ?? true) &&
@@ -388,33 +253,19 @@ export const Filters: TableFeature = {
         )
       },
 
-      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,
@@ -429,15 +280,15 @@ export const Filters: TableFeature = {
               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
@@ -452,21 +303,118 @@ export const Filters: TableFeature = {
           return [newFilterObj]
         })
       },
+      _getFacetedRowModel:
+        instance.options.getFacetedRowModel &&
+        instance.options.getFacetedRowModel(instance, column.id),
+      getFacetedRowModel: () => {
+        if (!column._getFacetedRowModel) {
+          return instance.getPreFilteredRowModel()
+        }
 
-      resetColumnFilters: () => {
-        instance.setColumnFilters(instance.initialState?.columnFilters ?? [])
+        return column._getFacetedRowModel()
       },
+      _getFacetedUniqueValues:
+        instance.options.getFacetedUniqueValues &&
+        instance.options.getFacetedUniqueValues(instance, column.id),
+      getFacetedUniqueValues: () => {
+        if (!column._getFacetedUniqueValues) {
+          return new Map()
+        }
 
-      getPreFilteredRowModel: () => instance.getCoreRowModel(),
-      getFilteredRowModel: () => {
-        if (
-          !instance._getFilteredRowModel &&
-          instance.options.getFilteredRowModel
-        ) {
-          instance._getFilteredRowModel =
-            instance.options.getFilteredRowModel(instance)
+        return column._getFacetedUniqueValues()
+      },
+      _getFacetedMinMaxValues:
+        instance.options.getFacetedMinMaxValues &&
+        instance.options.getFacetedMinMaxValues(instance, column.id),
+      getFacetedMinMaxValues: () => {
+        if (!column._getFacetedMinMaxValues) {
+          return [NaN, NaN]
+        }
+
+        return column._getFacetedMinMaxValues()
+      },
+      // () => [column.getFacetedRowModel()],
+      // facetedRowModel => getRowModelMinMaxValues(facetedRowModel, column.id),
+    }
+  },
+
+  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
+      },
+
+      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 = column.getFilterFn()
+
+              if (shouldAutoRemoveFilter(filterFn, filter.value, column)) {
+                return false
+              }
+            }
+
+            return true
+          })
         }
 
+        instance.options.onColumnFiltersChange?.(updateFn)
+      },
+
+      setGlobalFilter: updater => {
+        instance.options.onGlobalFilterChange?.(updater)
+      },
+
+      resetGlobalFilter: defaultState => {
+        instance.setGlobalFilter(
+          defaultState ? undefined : instance.initialState.globalFilter
+        )
+      },
+
+      resetColumnFilters: defaultState => {
+        instance.setColumnFilters(
+          defaultState ? [] : instance.initialState?.columnFilters ?? []
+        )
+      },
+
+      getPreFilteredRowModel: () => instance.getCoreRowModel(),
+      _getFilteredRowModel:
+        instance.options.getFilteredRowModel &&
+        instance.options.getFilteredRowModel(instance),
+      getFilteredRowModel: () => {
         if (
           instance.options.manualFiltering ||
           !instance._getFilteredRowModel
@@ -477,56 +425,42 @@ export const Filters: TableFeature = {
         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
-          }
+      _getGlobalFacetedRowModel:
+        instance.options.getFacetedRowModel &&
+        instance.options.getFacetedRowModel(instance, '__global__'),
 
-          return filterRows(
-            rowModel.rows,
-            columnFilters.map(d => d.id),
-            instance
-          )
-        },
-        {
-          key:
-            process.env.NODE_ENV === 'production' && 'getGlobalFacetedRowModel',
-          debug: () =>
-            instance.options.debugAll ?? instance.options.debugColumns,
+      getGlobalFacetedRowModel: () => {
+        if (
+          instance.options.manualFiltering ||
+          !instance._getGlobalFacetedRowModel
+        ) {
+          return instance.getPreFilteredRowModel()
         }
-      ),
-      getGlobalFacetedUniqueValues: memo(
-        () => [instance.getGlobalFacetedRowModel()],
-        facetedRowModel =>
-          getRowModelUniqueValues(facetedRowModel, '__global__'),
-        {
-          key:
-            process.env.NODE_ENV === 'production' &&
-            'getGlobalFacetedUniqueValues',
-          debug: () =>
-            instance.options.debugAll ?? instance.options.debugColumns,
+
+        return instance._getGlobalFacetedRowModel()
+      },
+
+      _getGlobalFacetedUniqueValues:
+        instance.options.getFacetedUniqueValues &&
+        instance.options.getFacetedUniqueValues(instance, '__global__'),
+      getGlobalFacetedUniqueValues: () => {
+        if (!instance._getGlobalFacetedUniqueValues) {
+          return new Map()
         }
-      ),
-      getGlobalFacetedMinMaxValues: memo(
-        () => [instance.getGlobalFacetedRowModel()],
-        facetedRowModel =>
-          getRowModelMinMaxValues(facetedRowModel, '__global__'),
-        {
-          key:
-            process.env.NODE_ENV === 'production' &&
-            'getGlobalFacetedMinMaxValues',
-          debug: () =>
-            instance.options.debugAll ?? instance.options.debugColumns,
+
+        return instance._getGlobalFacetedUniqueValues()
+      },
+
+      _getGlobalFacetedMinMaxValues:
+        instance.options.getFacetedMinMaxValues &&
+        instance.options.getFacetedMinMaxValues(instance, '__global__'),
+      getGlobalFacetedMinMaxValues: () => {
+        if (!instance._getGlobalFacetedMinMaxValues) {
+          return [NaN, NaN]
         }
-      ),
+
+        return instance._getGlobalFacetedMinMaxValues()
+      },
     }
   },
 }
@@ -544,44 +478,3 @@ 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
-}