@tanstack/react-table 8.0.0-alpha.6 → 8.0.0-alpha.9

package/src/features/Filters.ts

@@ -2,13 +2,19 @@ import { RowModel } from '..'
 import { BuiltInFilterType, filterTypes } from '../filterTypes'
 import {
   Column,
-  Listener,
   OnChangeFn,
-  ReactTable,
+  PartialGenerics,
+  TableInstance,
   Row,
   Updater,
 } from '../types'
-import { functionalUpdate, isFunction, makeStateUpdater, memo } from '../utils'
+import {
+  functionalUpdate,
+  isFunction,
+  makeStateUpdater,
+  memo,
+  Overwrite,
+} from '../utils'
 
 export type ColumnFilter = {
   id: string
@@ -17,42 +23,19 @@ export type ColumnFilter = {
 
 export type ColumnFiltersState = ColumnFilter[]
 
-export type FilterFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  {
-    (
-      rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-      columnIds: string[],
-      filterValue: any
-    ): any
-    autoRemove?: ColumnFilterAutoRemoveTestFn<
-      TData,
-      TValue,
-      TFilterFns,
-      TSortingFns,
-      TAggregationFns
-    >
-  }
+export type FilterFn<TGenerics extends PartialGenerics> = {
+  (rows: Row<TGenerics>[], columnIds: string[], filterValue: any): any
+  autoRemove?: ColumnFilterAutoRemoveTestFn<TGenerics>
+}
 
-export type ColumnFilterAutoRemoveTestFn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = (
+export type ColumnFilterAutoRemoveTestFn<TGenerics extends PartialGenerics> = (
   value: unknown,
-  column?: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+  column?: Column<TGenerics>
 ) => boolean
 
-export type CustomFilterTypes<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = Record<
+export type CustomFilterTypes<TGenerics extends PartialGenerics> = Record<
   string,
-  FilterFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+  FilterFn<TGenerics>
 >
 
 export type FiltersTableState = {
@@ -60,14 +43,14 @@ export type FiltersTableState = {
   globalFilter: any
 }
 
-export type FilterType<TFilterFns> =
+export type FilterType<TGenerics extends PartialGenerics> =
   | 'auto'
   | BuiltInFilterType
-  | keyof TFilterFns
-  | FilterFn<unknown, unknown, TFilterFns, any, any>
+  | TGenerics['FilterFns']
+  | FilterFn<TGenerics>
 
-export type FiltersColumnDef<TFilterFns> = {
-  filterType?: FilterType<TFilterFns>
+export type FiltersColumnDef<TGenerics extends PartialGenerics> = {
+  filterType?: FilterType<Overwrite<TGenerics, { Value: any }>>
   enableAllFilters?: boolean
   enableColumnFilter?: boolean
   enableGlobalFilter?: boolean
@@ -76,210 +59,82 @@ export type FiltersColumnDef<TFilterFns> = {
   defaultCanGlobalFilter?: boolean
 }
 
-export type FiltersColumn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
-  filterType: FilterType<TFilterFns>
+export type FiltersColumn<TGenerics extends PartialGenerics> = {
+  filterType: FilterType<Overwrite<TGenerics, { Value: any }>>
   getCanColumnFilter: () => boolean
   getCanGlobalFilter: () => boolean
   getColumnFilterIndex: () => number
   getIsColumnFiltered: () => boolean
   getColumnFilterValue: () => unknown
   setColumnFilterValue: (value: any) => void
-  getPreFilteredRows: () =>
-    | Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-    | undefined
+  getPreFilteredRows: () => Row<TGenerics>[] | undefined
   getPreFilteredUniqueValues: () => Map<any, number>
   getPreFilteredMinMaxValues: () => [any, any]
 }
 
-export type FiltersOptions<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
+export type FiltersOptions<TGenerics extends PartialGenerics> = {
   filterFromChildrenUp?: boolean
-  filterTypes?: TFilterFns
+  filterTypes?: TGenerics['FilterFns']
   enableFilters?: boolean
   // Column
   onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>
   autoResetColumnFilters?: boolean
   enableColumnFilters?: boolean
   columnFilterRowsFn?: (
-    instance: ReactTable<any, any, any, any, any>,
-    coreRowModel: RowModel<any, any, any, any, any>
-  ) => RowModel<any, any, any, any, any>
+    instance: TableInstance<TGenerics>,
+    coreRowModel: RowModel<TGenerics>
+  ) => RowModel<TGenerics>
   // Global
-  globalFilterType?: FilterType<TFilterFns>
+  globalFilterType?: FilterType<TGenerics>
   onGlobalFilterChange?: OnChangeFn<any>
   enableGlobalFilters?: boolean
   autoResetGlobalFilter?: boolean
   enableGlobalFilter?: boolean
   globalFilterRowsFn?: (
-    instance: ReactTable<any, any, any, any, any>,
-    rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  ) => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  getColumnCanGlobalFilterFn?: (
-    column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  ) => boolean
+    instance: TableInstance<TGenerics>,
+    rowModel: RowModel<TGenerics>
+  ) => RowModel<TGenerics>
+  getColumnCanGlobalFilterFn?: (column: Column<TGenerics>) => boolean
 }
 
-export type FiltersInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
+export type FiltersInstance<TGenerics extends PartialGenerics> = {
   _notifyFiltersReset: () => void
-  getColumnAutoFilterFn: (
-    columnId: string
-  ) => FilterFn<any, any, any, any, any> | undefined
+  getColumnAutoFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined
 
-  getColumnFilterFn: (
-    columnId: string
-  ) => FilterFn<any, any, any, any, any> | undefined
+  getColumnFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined
 
   setColumnFilters: (updater: Updater<ColumnFiltersState>) => void
   setColumnFilterValue: (columnId: string, value: any) => void
   resetColumnFilters: () => void
   getColumnCanColumnFilter: (columnId: string) => boolean
-  getColumnCanGlobalFilterFn?: (
-    column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  ) => boolean
+  getColumnCanGlobalFilterFn?: (column: Column<TGenerics>) => boolean
 
   getColumnIsFiltered: (columnId: string) => boolean
   getColumnFilterValue: (columnId: string) => unknown
   getColumnFilterIndex: (columnId: string) => number
-  getColumnFilteredRowModel: () => RowModel<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >
-  getPreFilteredRowModel: () => RowModel<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >
-  getPreFilteredRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getPreFilteredFlatRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getPreFilteredRowsById: () => Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  >
-  getPreColumnFilteredRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getPreColumnFilteredFlatRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getPreColumnFilteredRowsById: () => Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  >
-  getColumnFilteredRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getColumnFilteredFlatRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getColumnFilteredRowsById: () => Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  >
 
-  // Global
+  // All
+  getPreFilteredRowModel: () => RowModel<TGenerics>
+
+  // Column Filters
+  getPreColumnFilteredRowModel: () => RowModel<TGenerics>
+  getColumnFilteredRowModel: () => RowModel<TGenerics>
+
+  // Global Filters
   setGlobalFilter: (updater: Updater<any>) => void
   resetGlobalFilter: () => void
-  getGlobalAutoFilterFn: () => FilterFn<any, any, any, any, any> | undefined
-  getGlobalFilterFn: () => FilterFn<any, any, any, any, any> | undefined
+  getGlobalAutoFilterFn: () => FilterFn<TGenerics> | undefined
+  getGlobalFilterFn: () => FilterFn<TGenerics> | undefined
   getColumnCanGlobalFilter: (columnId: string) => boolean
-  getGlobalFilteredRowModel: () => RowModel<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >
-  getPreGlobalFilteredRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getPreGlobalFilteredFlatRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getPreGlobalFilteredRowsById: () => Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  >
-  getGlobalFilteredRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getGlobalFilteredFlatRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getGlobalFilteredRowsById: () => Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  >
+  getPreGlobalFilteredRowModel: () => RowModel<TGenerics>
+  getGlobalFilteredRowModel: () => RowModel<TGenerics>
 }
 
 //
 
-export function getDefaultColumn<TFilterFns>(): FiltersColumnDef<TFilterFns> {
+export function getDefaultColumn<
+  TGenerics extends PartialGenerics
+>(): FiltersColumnDef<TGenerics> {
   return {
     filterType: 'auto',
   }
@@ -292,15 +147,9 @@ export function getInitialState(): FiltersTableState {
   }
 }
 
-export function getDefaultOptions<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): FiltersOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
+export function getDefaultOptions<TGenerics extends PartialGenerics>(
+  instance: TableInstance<TGenerics>
+): FiltersOptions<TGenerics> {
   return {
     onColumnFiltersChange: makeStateUpdater('columnFilters', instance),
     onGlobalFilterChange: makeStateUpdater('globalFilter', instance),
@@ -309,25 +158,19 @@ export function getDefaultOptions<
     autoResetGlobalFilter: true,
     globalFilterType: 'auto',
     getColumnCanGlobalFilterFn: column => {
-      const value = instance.getCoreFlatRows()[0]?.getAllCellsByColumnId()[
-        column.id
-      ]?.value
+      const value = instance
+        .getCoreRowModel()
+        .flatRows[0]?.getAllCellsByColumnId()[column.id]?.value
 
       return typeof value === 'string'
     },
   }
 }
 
-export function createColumn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): FiltersColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
+export function createColumn<TGenerics extends PartialGenerics>(
+  column: Column<TGenerics>,
+  instance: TableInstance<TGenerics>
+): FiltersColumn<TGenerics> {
   const getFacetInfo = memo(
     () => [column.getPreFilteredRows()],
     (rows = []) => {
@@ -362,7 +205,10 @@ export function createColumn<
         preFilteredMinMaxValues,
       }
     },
-    { key: 'column.getFacetInfo', debug: instance.options.debug }
+    {
+      key: 'column.getFacetInfo',
+      debug: () => instance.options.debugAll ?? instance.options.debugColumns,
+    }
   )
 
   return {
@@ -379,15 +225,9 @@ export function createColumn<
   }
 }
 
-export function getInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): FiltersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
+export function getInstance<TGenerics extends PartialGenerics>(
+  instance: TableInstance<TGenerics>
+): FiltersInstance<TGenerics> {
   let registered = false
 
   return {
@@ -413,7 +253,7 @@ export function getInstance<
       }
     },
     getColumnAutoFilterFn: columnId => {
-      const firstRow = instance.getCoreFlatRows()[0]
+      const firstRow = instance.getCoreRowModel().flatRows[0]
 
       const value = firstRow?.values[columnId]
 
@@ -453,13 +293,9 @@ export function getInstance<
         : (userFilterTypes as Record<string, any>)?.[
             column.filterType as string
           ] ??
-          (filterTypes[column.filterType as BuiltInFilterType] as FilterFn<
-            TData,
-            TValue,
-            TFilterFns,
-            TSortingFns,
-            TAggregationFns
-          >)
+          (filterTypes[
+            column.filterType as BuiltInFilterType
+          ] as FilterFn<TGenerics>)
     },
 
     getGlobalFilterFn: () => {
@@ -473,13 +309,9 @@ export function getInstance<
         : (userFilterTypes as Record<string, any>)?.[
             globalFilterType as string
           ] ??
-          (filterTypes[globalFilterType as BuiltInFilterType] as FilterFn<
-            TData,
-            TValue,
-            TFilterFns,
-            TSortingFns,
-            TAggregationFns
-          >)
+          (filterTypes[
+            globalFilterType as BuiltInFilterType
+          ] as FilterFn<TGenerics>)
     },
 
     setColumnFilters: (updater: Updater<ColumnFiltersState>) => {
@@ -592,13 +424,7 @@ export function getInstance<
         //
         if (
           shouldAutoRemoveFilter(
-            filterFn as FilterFn<
-              TData,
-              TValue,
-              TFilterFns,
-              TSortingFns,
-              TAggregationFns
-            >,
+            filterFn as FilterFn<TGenerics>,
             newFilter,
             column
           )
@@ -631,6 +457,8 @@ export function getInstance<
       instance.setColumnFilters(instance.initialState?.columnFilters ?? [])
     },
 
+    getPreFilteredRowModel: () => instance.getCoreRowModel(),
+    getPreColumnFilteredRowModel: () => instance.getCoreRowModel(),
     getColumnFilteredRowModel: memo(
       () => [
         instance.getState().columnFilters,
@@ -643,9 +471,6 @@ export function getInstance<
             return rowModel
           }
 
-          if (process.env.NODE_ENV !== 'production' && instance.options.debug)
-            console.info('Column Filtering...')
-
           return columnFiltersFn(instance as any, rowModel)
         })()
 
@@ -667,25 +492,12 @@ export function getInstance<
 
         return columnFilteredRowModel
       },
-      { key: 'getColumnFilteredRowModel', debug: instance.options.debug }
+      {
+        key: 'getColumnFilteredRowModel',
+        debug: () => instance.options.debugAll ?? instance.options.debugTable,
+      }
     ),
-
-    // These might be easier to remember than "column" filtered rows
-    getPreFilteredRowModel: () => instance.getCoreRowModel(),
-    getPreFilteredRows: () => instance.getCoreRowModel().rows,
-    getPreFilteredFlatRows: () => instance.getCoreRowModel().flatRows,
-    getPreFilteredRowsById: () => instance.getCoreRowModel().rowsById,
-
-    // Pre Column Filter
-    getPreColumnFilteredRows: () => instance.getCoreRowModel().rows,
-    getPreColumnFilteredFlatRows: () => instance.getCoreRowModel().flatRows,
-    getPreColumnFilteredRowsById: () => instance.getCoreRowModel().rowsById,
-    getColumnFilteredRows: () => instance.getColumnFilteredRowModel().rows,
-
-    getColumnFilteredFlatRows: () =>
-      instance.getColumnFilteredRowModel().flatRows,
-    getColumnFilteredRowsById: () =>
-      instance.getColumnFilteredRowModel().rowsById,
+    getPreGlobalFilteredRowModel: () => instance.getColumnFilteredRowModel(),
     getGlobalFilteredRowModel: memo(
       () => [
         instance.getState().globalFilter,
@@ -698,11 +510,8 @@ export function getInstance<
             return columnFilteredRowModel
           }
 
-          if (process.env.NODE_ENV !== 'production' && instance.options.debug)
-            console.info('Global Filtering...')
-
           return globalFiltersFn(
-            instance as ReactTable<any, any, any, any, any>,
+            instance as TableInstance<TGenerics>,
             columnFilteredRowModel
           )
         })()
@@ -727,30 +536,19 @@ export function getInstance<
       },
       {
         key: 'getGlobalFilteredRowModel',
-        debug: instance.options.debug,
+        debug: () => instance.options.debugAll ?? instance.options.debugTable,
         onChange: () => {
           instance._notifySortingReset()
         },
       }
     ),
-
-    getPreGlobalFilteredRows: () => instance.getColumnFilteredRowModel().rows,
-    getPreGlobalFilteredFlatRows: () =>
-      instance.getColumnFilteredRowModel().flatRows,
-    getPreGlobalFilteredRowsById: () =>
-      instance.getColumnFilteredRowModel().rowsById,
-    getGlobalFilteredRows: () => instance.getGlobalFilteredRowModel().rows,
-    getGlobalFilteredFlatRows: () =>
-      instance.getGlobalFilteredRowModel().flatRows,
-    getGlobalFilteredRowsById: () =>
-      instance.getGlobalFilteredRowModel().rowsById,
   }
 }
 
-export function shouldAutoRemoveFilter(
-  filterFn?: FilterFn<any, any, any, any, any>,
+export function shouldAutoRemoveFilter<TGenerics extends PartialGenerics>(
+  filterFn?: FilterFn<TGenerics>,
   value?: any,
-  column?: Column<any, any, any, any, any>
+  column?: Column<TGenerics>
 ) {
   return (
     (filterFn && filterFn.autoRemove