@tanstack/table-core 8.0.0-alpha.64 → 8.0.0-alpha.68

package/src/features/Filters.ts

@@ -20,8 +20,8 @@ import {
 export type FiltersTableState = {
   columnFilters: ColumnFiltersState
   globalFilter: any
-  columnFiltersProgress: number
-  globalFilterProgress: number
+  // filtersProgress: number
+  // facetProgress: Record<string, number>
 }
 
 export type ColumnFiltersState = ColumnFilter[]
@@ -31,17 +31,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
 
@@ -60,72 +68,87 @@ export type FiltersColumnDef<TGenerics extends TableGenerics> = {
   filterFn?: FilterFnOption<Overwrite<TGenerics, { Value: any }>>
   enableColumnFilter?: boolean
   enableGlobalFilter?: 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>
+  _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> = {
+  columnFilterMap: Record<string, boolean>
+  subRowsByFacetId: Record<string, Row<TGenerics>[]>
 }
 
 export type FiltersOptions<TGenerics extends TableGenerics> = {
+  enableFilters?: boolean
+  manualFiltering?: boolean
   filterFromLeafRows?: boolean
   filterFns?: TGenerics['FilterFns']
+  getFilteredRowModel?: (
+    instance: TableInstance<TGenerics>
+  ) => () => RowModel<TGenerics>
 
   // Column
-  manualColumnFiltering?: boolean
   onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>
   enableColumnFilters?: boolean
-  getColumnFilteredRowModel?: (
-    instance: TableInstance<TGenerics>
-  ) => () => RowModel<TGenerics>
 
   // Global
-  manualGlobalFiltering?: boolean
   globalFilterFn?: FilterFnOption<TGenerics>
   onGlobalFilterChange?: OnChangeFn<any>
   enableGlobalFilter?: boolean
-  getGlobalFilteredRowModel?: (
-    instance: TableInstance<TGenerics>
-  ) => () => RowModel<TGenerics>
   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
 
-  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>
+  _getGlobalFacetedRowModel?: () => RowModel<TGenerics>
+  getGlobalFacetedUniqueValues: () => Map<any, number>
+  _getGlobalFacetedUniqueValues?: () => Map<any, number>
+  getGlobalFacetedMinMaxValues: () => [number, number]
+  _getGlobalFacetedMinMaxValues?: () => [number, number]
 }
 
 //
@@ -143,8 +166,8 @@ export const Filters: TableFeature = {
     return {
       columnFilters: [],
       globalFilter: undefined,
-      columnFiltersProgress: 1,
-      globalFilterProgress: 1,
+      // filtersProgress: 1,
+      // facetProgress: {},
       ...state,
     }
   },
@@ -155,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'
       },
@@ -171,76 +195,19 @@ export const Filters: TableFeature = {
     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?.getValue(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') {
@@ -253,21 +220,13 @@ export const Filters: TableFeature = {
 
         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
             ] ??
@@ -275,111 +234,38 @@ export const Filters: TableFeature = {
               column.filterFn as BuiltInFilterFn
             ] as FilterFn<TGenerics>)
       },
-
-      getGlobalFilterFn: () => {
-        const { filterFns: userFilterFns, globalFilterFn: globalFilterFn } =
-          instance.options
-
-        debugger
-
-        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) &&
+          (instance.options.enableFilters ?? true) &&
           !!column.accessorFn
         )
       },
 
-      getColumnCanGlobalFilter: columnId => {
-        const column = instance.getColumn(columnId)
-
-        if (!column) {
-          throw new Error()
-        }
-
+      getCanGlobalFilter: () => {
         return (
           (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,
@@ -394,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
@@ -417,48 +303,159 @@ export const Filters: TableFeature = {
           return [newFilterObj]
         })
       },
+      _getFacetedRowModel:
+        instance.options.getFacetedRowModel &&
+        instance.options.getFacetedRowModel(instance, column.id),
+      getFacetedRowModel: () => {
+        if (!column._getFacetedRowModel) {
+          return instance.getPreFilteredRowModel()
+        }
+
+        return column._getFacetedRowModel()
+      },
+      _getFacetedUniqueValues:
+        instance.options.getFacetedUniqueValues &&
+        instance.options.getFacetedUniqueValues(instance, column.id),
+      getFacetedUniqueValues: () => {
+        if (!column._getFacetedUniqueValues) {
+          return new Map()
+        }
+
+        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: () => {
+        instance.setGlobalFilter(instance.initialState.globalFilter)
+      },
 
       resetColumnFilters: () => {
         instance.setColumnFilters(instance.initialState?.columnFilters ?? [])
       },
 
-      getPreColumnFilteredRowModel: () => instance.getCoreRowModel(),
-      getColumnFilteredRowModel: () => {
+      getPreFilteredRowModel: () => instance.getCoreRowModel(),
+      _getFilteredRowModel:
+        instance.options.getFilteredRowModel &&
+        instance.options.getFilteredRowModel(instance),
+      getFilteredRowModel: () => {
         if (
-          !instance._getColumnFilteredRowModel &&
-          instance.options.getColumnFilteredRowModel
+          instance.options.manualFiltering ||
+          !instance._getFilteredRowModel
         ) {
-          instance._getColumnFilteredRowModel =
-            instance.options.getColumnFilteredRowModel(instance)
+          return instance.getPreFilteredRowModel()
         }
 
+        return instance._getFilteredRowModel()
+      },
+
+      _getGlobalFacetedRowModel:
+        instance.options.getFacetedRowModel &&
+        instance.options.getFacetedRowModel(instance, '__global__'),
+
+      getGlobalFacetedRowModel: () => {
         if (
-          instance.options.manualColumnFiltering ||
-          !instance._getColumnFilteredRowModel
+          instance.options.manualFiltering ||
+          !instance._getGlobalFacetedRowModel
         ) {
-          return instance.getPreColumnFilteredRowModel()
+          return instance.getPreFilteredRowModel()
         }
 
-        return instance._getColumnFilteredRowModel()
+        return instance._getGlobalFacetedRowModel()
       },
-      getPreGlobalFilteredRowModel: () => instance.getColumnFilteredRowModel(),
-      getGlobalFilteredRowModel: () => {
-        if (
-          !instance._getGlobalFilteredRowModel &&
-          instance.options.getGlobalFilteredRowModel
-        ) {
-          instance._getGlobalFilteredRowModel =
-            instance.options.getGlobalFilteredRowModel(instance)
+
+      _getGlobalFacetedUniqueValues:
+        instance.options.getFacetedUniqueValues &&
+        instance.options.getFacetedUniqueValues(instance, '__global__'),
+      getGlobalFacetedUniqueValues: () => {
+        if (!instance._getGlobalFacetedUniqueValues) {
+          return new Map()
         }
 
-        if (
-          instance.options.manualGlobalFiltering ||
-          !instance._getGlobalFilteredRowModel
-        ) {
-          return instance.getPreGlobalFilteredRowModel()
+        return instance._getGlobalFacetedUniqueValues()
+      },
+
+      _getGlobalFacetedMinMaxValues:
+        instance.options.getFacetedMinMaxValues &&
+        instance.options.getFacetedMinMaxValues(instance, '__global__'),
+      getGlobalFacetedMinMaxValues: () => {
+        if (!instance._getGlobalFacetedMinMaxValues) {
+          return [NaN, NaN]
         }
 
-        return instance._getGlobalFilteredRowModel()
+        return instance._getGlobalFacetedMinMaxValues()
       },
     }
   },