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

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[]
@@ -80,11 +79,14 @@ export type FiltersColumn<TGenerics extends TableGenerics> = {
   getCanFilter: () => boolean
   getCanGlobalFilter: () => boolean
   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> = {
@@ -97,25 +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> = {
   setColumnFilters: (updater: Updater<ColumnFiltersState>) => void
 
-  resetColumnFilters: () => void
+  resetColumnFilters: (defaultState?: boolean) => void
 
   // Column Filters
   getPreFilteredRowModel: () => RowModel<TGenerics>
@@ -124,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
-
   getGlobalFacetedRowModel: () => RowModel<TGenerics>
+  _getGlobalFacetedRowModel?: () => RowModel<TGenerics>
   getGlobalFacetedUniqueValues: () => Map<any, number>
+  _getGlobalFacetedUniqueValues?: () => Map<any, number>
   getGlobalFacetedMinMaxValues: () => [number, number]
+  _getGlobalFacetedMinMaxValues?: () => [number, number]
 }
 
 //
@@ -148,8 +166,8 @@ export const Filters: TableFeature = {
     return {
       columnFilters: [],
       globalFilter: undefined,
-      columnFiltersProgress: 1,
-      globalFilterProgress: 1,
+      // filtersProgress: 1,
+      // facetProgress: {},
       ...state,
     }
   },
@@ -160,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'
       },
@@ -181,7 +200,7 @@ export const Filters: TableFeature = {
       getAutoFilterFn: () => {
         const firstRow = instance.getCoreRowModel().flatRows[0]
 
-        const value = firstRow?.values[column.id]
+        const value = firstRow?.getValue(column.id)
 
         if (typeof value === 'string') {
           return filterFns.includesString
@@ -284,58 +303,38 @@ export const Filters: TableFeature = {
           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
-          }
-
-          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,
+      _getFacetedRowModel:
+        instance.options.getFacetedRowModel &&
+        instance.options.getFacetedRowModel(instance, column.id),
+      getFacetedRowModel: () => {
+        if (!column._getFacetedRowModel) {
+          return instance.getPreFilteredRowModel()
         }
-      ),
-      getFacetedUniqueValues: memo(
-        () => [column.getFacetedRowModel()],
-        facetedRowModel => getRowModelUniqueValues(facetedRowModel, column.id),
-        {
-          key:
-            process.env.NODE_ENV === 'production' &&
-            'column.getFacetedUniqueValues',
-          debug: () =>
-            instance.options.debugAll ?? instance.options.debugColumns,
+
+        return column._getFacetedRowModel()
+      },
+      _getFacetedUniqueValues:
+        instance.options.getFacetedUniqueValues &&
+        instance.options.getFacetedUniqueValues(instance, column.id),
+      getFacetedUniqueValues: () => {
+        if (!column._getFacetedUniqueValues) {
+          return new Map()
         }
-      ),
-      getFacetedMinMaxValues: memo(
-        () => [column.getFacetedRowModel()],
-        facetedRowModel => getRowModelMinMaxValues(facetedRowModel, column.id),
-        {
-          key:
-            process.env.NODE_ENV === 'production' &&
-            'column.getFacetedMinMaxValues',
-          debug: () =>
-            instance.options.debugAll ?? instance.options.debugColumns,
+
+        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),
     }
   },
 
@@ -399,24 +398,23 @@ export const Filters: TableFeature = {
         instance.options.onGlobalFilterChange?.(updater)
       },
 
-      resetGlobalFilter: () => {
-        instance.setGlobalFilter(instance.initialState.globalFilter)
+      resetGlobalFilter: defaultState => {
+        instance.setGlobalFilter(
+          defaultState ? undefined : instance.initialState.globalFilter
+        )
       },
 
-      resetColumnFilters: () => {
-        instance.setColumnFilters(instance.initialState?.columnFilters ?? [])
+      resetColumnFilters: defaultState => {
+        instance.setColumnFilters(
+          defaultState ? [] : instance.initialState?.columnFilters ?? []
+        )
       },
 
       getPreFilteredRowModel: () => instance.getCoreRowModel(),
+      _getFilteredRowModel:
+        instance.options.getFilteredRowModel &&
+        instance.options.getFilteredRowModel(instance),
       getFilteredRowModel: () => {
-        if (
-          !instance._getFilteredRowModel &&
-          instance.options.getFilteredRowModel
-        ) {
-          instance._getFilteredRowModel =
-            instance.options.getFilteredRowModel(instance)
-        }
-
         if (
           instance.options.manualFiltering ||
           !instance._getFilteredRowModel
@@ -427,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()
+      },
     }
   },
 }
@@ -494,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
-}

package/src/features/Grouping.ts

@@ -45,7 +45,7 @@ export type GroupingColumnDef<TGenerics extends TableGenerics> = {
       row: Row<TGenerics>
       column: Column<TGenerics>
       cell: Cell<TGenerics>
-      value: TGenerics['Value']
+      getValue: () => TGenerics['Value']
     }
   >
   enableGrouping?: boolean
@@ -58,12 +58,15 @@ export type GroupingColumn<TGenerics extends TableGenerics> = {
   getGroupedIndex: () => number
   toggleGrouping: () => void
   getToggleGroupingHandler: () => () => void
+  getColumnAutoAggregationFn: () => AggregationFn<TGenerics> | undefined
+  getColumnAggregationFn: () => AggregationFn<TGenerics> | undefined
 }
 
 export type GroupingRow = {
   groupingColumnId?: string
   groupingValue?: any
   getIsGrouped: () => boolean
+  groupingValuesCache: Record<string, any>
 }
 
 export type GroupingCell<TGenerics extends TableGenerics> = {
@@ -95,14 +98,8 @@ export type GroupingOptions<TGenerics extends TableGenerics> = {
 export type GroupingColumnMode = false | 'reorder' | 'remove'
 
 export type GroupingInstance<TGenerics extends TableGenerics> = {
-  getColumnAutoAggregationFn: (
-    columnId: string
-  ) => AggregationFn<TGenerics> | undefined
-  getColumnAggregationFn: (
-    columnId: string
-  ) => AggregationFn<TGenerics> | undefined
   setGrouping: (updater: Updater<GroupingState>) => void
-  resetGrouping: () => void
+  resetGrouping: (defaultState?: boolean) => void
   getPreGroupedRowModel: () => RowModel<TGenerics>
   getGroupedRowModel: () => RowModel<TGenerics>
   _getGroupedRowModel?: () => RowModel<TGenerics>
@@ -175,17 +172,10 @@ export const Grouping: TableFeature = {
           column.toggleGrouping()
         }
       },
-    }
-  },
-
-  createInstance: <TGenerics extends TableGenerics>(
-    instance: TableInstance<TGenerics>
-  ): GroupingInstance<TGenerics> => {
-    return {
-      getColumnAutoAggregationFn: columnId => {
+      getColumnAutoAggregationFn: () => {
         const firstRow = instance.getCoreRowModel().flatRows[0]
 
-        const value = firstRow?.values[columnId]
+        const value = firstRow?.getValue(column.id)
 
         if (typeof value === 'number') {
           return aggregationFns.sum
@@ -197,8 +187,7 @@ export const Grouping: TableFeature = {
 
         return aggregationFns.count
       },
-      getColumnAggregationFn: columnId => {
-        const column = instance.getColumn(columnId)
+      getColumnAggregationFn: () => {
         const userAggregationFns = instance.options.aggregationFns
 
         if (!column) {
@@ -208,7 +197,7 @@ export const Grouping: TableFeature = {
         return isFunction(column.aggregationFn)
           ? column.aggregationFn
           : column.aggregationFn === 'auto'
-          ? instance.getColumnAutoAggregationFn(columnId)
+          ? column.getColumnAutoAggregationFn()
           : (userAggregationFns as Record<string, any>)?.[
               column.aggregationFn as string
             ] ??
@@ -216,11 +205,19 @@ export const Grouping: TableFeature = {
               column.aggregationFn as BuiltInAggregationFn
             ] as AggregationFn<TGenerics>)
       },
+    }
+  },
 
+  createInstance: <TGenerics extends TableGenerics>(
+    instance: TableInstance<TGenerics>
+  ): GroupingInstance<TGenerics> => {
+    return {
       setGrouping: updater => instance.options.onGroupingChange?.(updater),
 
-      resetGrouping: () => {
-        instance.setGrouping(instance.initialState?.grouping ?? [])
+      resetGrouping: defaultState => {
+        instance.setGrouping(
+          defaultState ? [] : instance.initialState?.grouping ?? []
+        )
       },
 
       getPreGroupedRowModel: () => instance.getSortedRowModel(),
@@ -248,6 +245,7 @@ export const Grouping: TableFeature = {
   ): GroupingRow => {
     return {
       getIsGrouped: () => !!row.groupingColumnId,
+      groupingValuesCache: {},
     }
   },
 
@@ -274,7 +272,7 @@ export const Grouping: TableFeature = {
               column,
               row,
               cell,
-              value: cell.value,
+              getValue: cell.getValue,
             })
           : null
       },

package/src/features/Ordering.ts

@@ -27,7 +27,7 @@ export type ColumnOrderDefaultOptions = {
 
 export type ColumnOrderInstance<TGenerics extends TableGenerics> = {
   setColumnOrder: (updater: Updater<ColumnOrderState>) => void
-  resetColumnOrder: () => void
+  resetColumnOrder: (defaultState?: boolean) => void
   _getOrderColumnsFn: () => (
     columns: Column<TGenerics>[]
   ) => Column<TGenerics>[]
@@ -57,8 +57,10 @@ export const Ordering: TableFeature = {
     return {
       setColumnOrder: updater =>
         instance.options.onColumnOrderChange?.(updater),
-      resetColumnOrder: () => {
-        instance.setColumnOrder(instance.initialState.columnOrder ?? [])
+      resetColumnOrder: defaultState => {
+        instance.setColumnOrder(
+          defaultState ? [] : instance.initialState.columnOrder ?? []
+        )
       },
       _getOrderColumnsFn: memo(
         () => [

package/src/features/Pagination.ts

@@ -11,7 +11,7 @@ import { functionalUpdate, makeStateUpdater, memo } from '../utils'
 export type PaginationState = {
   pageIndex: number
   pageSize: number
-  pageCount: number
+  pageCount?: number
 }
 
 export type PaginationTableState = {
@@ -39,11 +39,11 @@ export type PaginationDefaultOptions = {
 export type PaginationInstance<TGenerics extends TableGenerics> = {
   _autoResetPageIndex: () => void
   setPagination: (updater: Updater<PaginationState>) => void
-  resetPagination: () => void
+  resetPagination: (defaultState?: boolean) => void
   setPageIndex: (updater: Updater<number>) => void
-  resetPageIndex: () => void
+  resetPageIndex: (defaultState?: boolean) => void
   setPageSize: (updater: Updater<number>) => void
-  resetPageSize: () => void
+  resetPageSize: (defaultState?: boolean) => void
   setPageCount: (updater: Updater<number>) => void
   getPageOptions: () => number[]
   getCanPreviousPage: () => boolean
@@ -58,14 +58,20 @@ export type PaginationInstance<TGenerics extends TableGenerics> = {
 
 //
 
+const defaultPageIndex = 0
+const defaultPageSize = 10
+
+const getDefaultPaginationState = (): PaginationState => ({
+  pageIndex: defaultPageIndex,
+  pageSize: defaultPageSize,
+})
+
 export const Pagination: TableFeature = {
   getInitialState: (state): PaginationTableState => {
     return {
       ...state,
       pagination: {
-        pageCount: -1,
-        pageIndex: 0,
-        pageSize: 10,
+        ...getDefaultPaginationState(),
         ...state?.pagination,
       },
     }
@@ -112,13 +118,11 @@ export const Pagination: TableFeature = {
 
         return instance.options.onPaginationChange?.(safeUpdater)
       },
-      resetPagination: () => {
+      resetPagination: defaultState => {
         instance.setPagination(
-          instance.initialState.pagination ?? {
-            pageIndex: 0,
-            pageSize: 10,
-            pageCount: -1,
-          }
+          defaultState
+            ? getDefaultPaginationState()
+            : instance.initialState.pagination ?? getDefaultPaginationState()
         )
       },
       setPageIndex: updater => {
@@ -138,11 +142,19 @@ export const Pagination: TableFeature = {
           }
         })
       },
-      resetPageIndex: () => {
-        instance.setPageIndex(0)
+      resetPageIndex: defaultState => {
+        instance.setPageIndex(
+          defaultState
+            ? defaultPageIndex
+            : instance.initialState?.pagination?.pageIndex ?? defaultPageIndex
+        )
       },
-      resetPageSize: () => {
-        instance.setPageSize(instance.initialState?.pagination?.pageSize ?? 10)
+      resetPageSize: defaultState => {
+        instance.setPageSize(
+          defaultState
+            ? defaultPageSize
+            : instance.initialState?.pagination?.pageSize ?? defaultPageSize
+        )
       },
       setPageSize: updater => {
         instance.setPagination(old => {
@@ -159,7 +171,7 @@ export const Pagination: TableFeature = {
       },
       setPageCount: updater =>
         instance.setPagination(old => {
-          let newPageCount = functionalUpdate(updater, old.pageCount)
+          let newPageCount = functionalUpdate(updater, old.pageCount ?? -1)
 
           if (typeof newPageCount === 'number') {
             newPageCount = Math.max(-1, newPageCount)
@@ -239,7 +251,8 @@ export const Pagination: TableFeature = {
 
       getPageCount: () => {
         const { pageCount } = instance.getState().pagination
-        if (pageCount > 0) {
+
+        if (typeof pageCount !== 'undefined') {
           return pageCount
         }
 

package/src/features/Pinning.ts

@@ -49,7 +49,7 @@ export type ColumnPinningRow<TGenerics extends TableGenerics> = {
 
 export type ColumnPinningInstance<TGenerics extends TableGenerics> = {
   setColumnPinning: (updater: Updater<ColumnPinningState>) => void
-  resetColumnPinning: () => void
+  resetColumnPinning: (defaultState?: boolean) => void
   getIsSomeColumnsPinned: () => boolean
   getLeftLeafColumns: () => Column<TGenerics>[]
   getRightLeafColumns: () => Column<TGenerics>[]
@@ -58,13 +58,15 @@ export type ColumnPinningInstance<TGenerics extends TableGenerics> = {
 
 //
 
+const getDefaultPinningState = (): ColumnPinningState => ({
+  left: [],
+  right: [],
+})
+
 export const Pinning: TableFeature = {
   getInitialState: (state): ColumnPinningTableState => {
     return {
-      columnPinning: {
-        left: [],
-        right: [],
-      },
+      columnPinning: getDefaultPinningState(),
       ...state,
     }
   },
@@ -220,8 +222,12 @@ export const Pinning: TableFeature = {
       setColumnPinning: updater =>
         instance.options.onColumnPinningChange?.(updater),
 
-      resetColumnPinning: () =>
-        instance.setColumnPinning(instance.initialState?.columnPinning ?? {}),
+      resetColumnPinning: defaultState =>
+        instance.setColumnPinning(
+          defaultState
+            ? getDefaultPinningState()
+            : instance.initialState?.columnPinning ?? getDefaultPinningState()
+        ),
 
       getIsSomeColumnsPinned: () => {
         const { left, right } = instance.getState().columnPinning