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

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,19 +99,33 @@ 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> = {
@@ -127,10 +143,12 @@ export type FiltersInstance<TGenerics extends TableGenerics> = {
   resetGlobalFilter: () => 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),
     }
   },
 
@@ -408,15 +407,10 @@ export const Filters: TableFeature = {
       },
 
       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 +421,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 +474,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,12 +98,6 @@ 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
   getPreGroupedRowModel: () => 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,7 +205,13 @@ 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: () => {
@@ -248,6 +243,7 @@ export const Grouping: TableFeature = {
   ): GroupingRow => {
     return {
       getIsGrouped: () => !!row.groupingColumnId,
+      groupingValuesCache: {},
     }
   },
 
@@ -274,7 +270,7 @@ export const Grouping: TableFeature = {
               column,
               row,
               cell,
-              value: cell.value,
+              getValue: cell.getValue,
             })
           : null
       },

package/src/features/Rows.ts

@@ -12,7 +12,8 @@ export type CoreRow<TGenerics extends TableGenerics> = {
   index: number
   original?: TGenerics['Row']
   depth: number
-  values: RowValues
+  valuesCache: Record<string, any>
+  getValue: (columnId: string) => any
   subRows: Row<TGenerics>[]
   getLeafRows: () => Row<TGenerics>[]
   originalSubRows?: TGenerics['Row'][]
@@ -44,7 +45,7 @@ export type RowsInstance<TGenerics extends TableGenerics> = {
     original: TGenerics['Row'] | undefined,
     rowIndex: number,
     depth: number,
-    values: Record<string, any>
+    subRows?: Row<TGenerics>[]
   ) => Row<TGenerics>
   getCoreRowModel: () => RowModel<TGenerics>
   _getCoreRowModel?: () => RowModel<TGenerics>
@@ -73,20 +74,34 @@ export const Rows = {
       ) =>
         instance.options.getRowId?.(row, index, parent) ??
         `${parent ? [parent.id, index].join('.') : index}`,
-      createRow: (id, original, rowIndex, depth, values) => {
+      createRow: (id, original, rowIndex, depth, subRows) => {
         let row: CoreRow<TGenerics> = {
           id,
           index: rowIndex,
           original,
           depth,
-          values,
-          subRows: [],
+          valuesCache: {},
+          getValue: columnId => {
+            if (row.valuesCache.hasOwnProperty(columnId)) {
+              return row.valuesCache[columnId]
+            }
+            const column = instance.getColumn(columnId)
+            if (!column.accessorFn) {
+              throw new Error()
+            }
+            row.valuesCache[columnId] = column.accessorFn(
+              row.original,
+              rowIndex
+            )
+            return row.valuesCache[columnId]
+          },
+          subRows: subRows ?? [],
           getLeafRows: () => flattenBy(row.subRows, d => d.subRows),
         }
 
         for (let i = 0; i < instance._features.length; i++) {
           const feature = instance._features[i]
-          Object.assign(row, feature.createRow?.(row, instance))
+          Object.assign(row, feature?.createRow?.(row, instance))
         }
 
         return row as Row<TGenerics>

package/src/features/Sorting.ts

@@ -130,7 +130,7 @@ export const Sorting: TableFeature = {
         let isString = false
 
         for (const row of firstRows) {
-          const value = row?.values[column.id]
+          const value = row?.getValue(column.id)
 
           if (Object.prototype.toString.call(value) === '[object Date]') {
             return sortingFns.datetime
@@ -154,7 +154,7 @@ export const Sorting: TableFeature = {
       getAutoSortDir: () => {
         const firstRow = instance.getFilteredRowModel().flatRows[0]
 
-        const value = firstRow?.values[column.id]
+        const value = firstRow?.getValue(column.id)
 
         if (typeof value === 'string') {
           return 'asc'

package/src/filterFns.ts

@@ -6,7 +6,7 @@ const includesString: FilterFn<any> = (
   filterValue: string
 ) => {
   const search = filterValue.toLowerCase()
-  return row.values[columnId].toLowerCase().includes(search)
+  return row.getValue(columnId).toLowerCase().includes(search)
 }
 
 includesString.autoRemove = (val: any) => testFalsey(val)
@@ -16,7 +16,7 @@ const includesStringSensitive: FilterFn<any> = (
   columnId: string,
   filterValue: string
 ) => {
-  return row.values[columnId].includes(filterValue)
+  return row.getValue(columnId).includes(filterValue)
 }
 
 includesStringSensitive.autoRemove = (val: any) => testFalsey(val)
@@ -26,7 +26,7 @@ const equalsString: FilterFn<any> = (
   columnId: string,
   filterValue: string
 ) => {
-  return row.values[columnId].toLowerCase() === filterValue.toLowerCase()
+  return row.getValue(columnId).toLowerCase() === filterValue.toLowerCase()
 }
 
 equalsString.autoRemove = (val: any) => testFalsey(val)
@@ -36,7 +36,7 @@ const arrIncludes: FilterFn<any> = (
   columnId: string,
   filterValue: unknown
 ) => {
-  return row.values[columnId].includes(filterValue)
+  return row.getValue(columnId).includes(filterValue)
 }
 
 arrIncludes.autoRemove = (val: any) => testFalsey(val) || !val?.length
@@ -46,7 +46,7 @@ const arrIncludesAll: FilterFn<any> = (
   columnId: string,
   filterValue: unknown[]
 ) => {
-  return !filterValue.some(val => !row.values[columnId].includes(val))
+  return !filterValue.some(val => !row.getValue(columnId).includes(val))
 }
 
 arrIncludesAll.autoRemove = (val: any) => testFalsey(val) || !val?.length
@@ -56,13 +56,13 @@ const arrIncludesSome: FilterFn<any> = (
   columnId: string,
   filterValue: unknown[]
 ) => {
-  return filterValue.some(val => row.values[columnId].includes(val))
+  return filterValue.some(val => row.getValue(columnId).includes(val))
 }
 
 arrIncludesSome.autoRemove = (val: any) => testFalsey(val) || !val?.length
 
 const equals: FilterFn<any> = (row, columnId: string, filterValue: unknown) => {
-  return row.values[columnId] === filterValue
+  return row.getValue(columnId) === filterValue
 }
 
 equals.autoRemove = (val: any) => testFalsey(val)
@@ -72,7 +72,7 @@ const weakEquals: FilterFn<any> = (
   columnId: string,
   filterValue: unknown
 ) => {
-  return row.values[columnId] == filterValue
+  return row.getValue(columnId) == filterValue
 }
 
 weakEquals.autoRemove = (val: any) => testFalsey(val)
@@ -84,7 +84,7 @@ const inNumberRange: FilterFn<any> = (
 ) => {
   let [min, max] = filterValue
 
-  const rowValue = row.values[columnId]
+  const rowValue = row.getValue(columnId)
   return rowValue >= min && rowValue <= max
 }
 

package/src/index.ts

@@ -15,10 +15,18 @@ export * from './features/Sorting'
 export * from './features/Visibility'
 export * from './features/Expanding'
 export * from './utils'
-export * from './utils/getCoreRowModelSync'
-export * from './utils/getCoreRowModelAsync'
-export * from './utils/getFilteredRowModelSync'
-export * from './utils/getSortedRowModelSync'
+export * from './utils/getCoreRowModel'
+export * from './utils/getFilteredRowModel'
+export * from './utils/getFacetedRowModel'
+export * from './utils/getFacetedUniqueValues'
+export * from './utils/getFacetedMinMaxValues'
+export * from './utils/getSortedRowModel'
 export * from './utils/getGroupedRowModel'
 export * from './utils/getExpandedRowModel'
 export * from './utils/getPaginationRowModel'
+// Experimental Async
+// export * from './utils/getCoreRowModelAsync'
+// export * from './utils/getFilteredRowModelAsync'
+// export * from './utils/getFacetedRowModelAsync'
+// export * from './utils/getFacetedUniqueValuesAsync'
+// export * from './utils/getFacetedMinMaxValuesAsync'