@tanstack/table-core 8.0.0-alpha.42 → 8.0.0-alpha.45

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/table-core",
   "author": "Tanner Linsley",
-  "version": "8.0.0-alpha.42",
+  "version": "8.0.0-alpha.45",
   "description": "Hooks for building lightweight, fast and extendable datagrids for React",
   "license": "MIT",
   "homepage": "https://github.com/tanstack/react-table#readme",

package/src/{aggregationTypes.ts → aggregationFns.ts}

@@ -1,4 +1,4 @@
-export const aggregationTypes = {
+export const aggregationFns = {
   sum,
   min,
   max,
@@ -10,7 +10,7 @@ export const aggregationTypes = {
   count,
 }
 
-export type BuiltInAggregationType = keyof typeof aggregationTypes
+export type BuiltInAggregationType = keyof typeof aggregationFns
 
 function sum(_getLeafValues: () => unknown[], getChildValues: () => unknown[]) {
   // It's faster to just add the aggregations together instead of

package/src/core.ts

@@ -26,7 +26,6 @@ import {
   CellProps,
   TableInstance,
   RowValues,
-  PartialGenerics,
   CoreCell,
   Renderable,
   UseRenderer,
@@ -46,7 +45,7 @@ import { RowSelection } from './features/RowSelection'
 import { Sorting } from './features/Sorting'
 import { Visibility } from './features/Visibility'
 import { Headers } from './features/Headers'
-import { mean } from './aggregationTypes'
+import { mean } from './aggregationFns'
 
 const features: TableFeature[] = [
   Headers,
@@ -310,7 +309,8 @@ export function createTableInstance<TGenerics extends AnyGenerics>(
       return template
     },
 
-    getRowId: (_: TGenerics['Row'], index: number, parent?: Row<TGenerics>) =>
+    getRowId: (row: TGenerics['Row'], index: number, parent?: Row<TGenerics>) =>
+      instance.options.getRowId?.(row, index, parent) ??
       `${parent ? [parent.id, index].join('.') : index}`,
 
     getState: () => {

package/src/createTable.ts

@@ -1,38 +1,60 @@
-import { CustomFilterTypes } from './features/Filters'
-import { CustomAggregationTypes } from './features/Grouping'
-import { CustomSortingTypes } from './features/Sorting'
-import {
-  ColumnDef,
-  AccessorFn,
-  PartialGenerics,
-  AnyRender,
-  AnyGenerics,
-} from './types'
-import { Overwrite, PartialKeys } from './utils'
+import { CustomFilterTypes, FilterFn } from './features/Filters'
+import { AggregationFn, CustomAggregationTypes } from './features/Grouping'
+import { CustomSortingTypes, SortingFn } from './features/Sorting'
+import { ColumnDef, AccessorFn, AnyRender, AnyGenerics, Options } from './types'
+import { IfDefined, Overwrite, PartialKeys } from './utils'
 
-export type CreateTableFactory<TGenerics extends AnyGenerics> = <
-  TSubGenerics extends {
-    Row: any
-    ColumnMeta?: object
-    TableMeta?: object
-  }
->() => Table<Overwrite<TGenerics, TSubGenerics>>
+export type TableFactory<TGenerics extends AnyGenerics> = () => Table<TGenerics>
 
-export type CreateTableFactoryOptions<
+export type CreateTableOptions<
   TRender extends AnyRender,
   TFilterFns extends CustomFilterTypes<any>,
   TSortingFns extends CustomSortingTypes<any>,
-  TAggregationFns extends CustomAggregationTypes<any>
-> = {
-  render: TRender
-  filterFns?: TFilterFns
-  sortingFns?: TSortingFns
-  aggregationFns?: TAggregationFns
-}
+  TAggregationFns extends CustomAggregationTypes<any>,
+  TGenerics extends AnyGenerics
+> = Partial<
+  {
+    render?: TRender
+    filterFns?: TFilterFns
+    sortingFns?: TSortingFns
+    aggregationFns?: TAggregationFns
+  } & Omit<Options<TGenerics>, 'filterFns' | 'sortingFns' | 'aggregationFns'>
+>
 
 export type Table<TGenerics extends AnyGenerics> = {
   generics: TGenerics
-  __options: CreateTableFactoryOptions<any, any, any, any>
+  options: Partial<Options<TGenerics>>
+  setRowType: <TRow extends object>() => Table<
+    Overwrite<TGenerics, { Row: TRow }>
+  >
+  setTableMetaType: <TTableMeta extends object>() => Table<
+    Overwrite<TGenerics, { TableMeta: TTableMeta }>
+  >
+  setColumnMetaType: <TColumnMeta extends object>() => Table<
+    Overwrite<TGenerics, { ColumnMeta: TColumnMeta }>
+  >
+  setOptions: <
+    TFilterFns extends Record<string, FilterFn<any>>,
+    TSortingFns extends Record<string, SortingFn<any>>,
+    TAggregationFns extends Record<string, AggregationFn<any>>
+  >(
+    options: CreateTableOptions<
+      any,
+      TFilterFns,
+      TSortingFns,
+      TAggregationFns,
+      TGenerics
+    >
+  ) => Table<
+    Overwrite<
+      TGenerics,
+      {
+        FilterFns: IfDefined<TFilterFns, TGenerics['FilterFns']>
+        SortingFns: IfDefined<TSortingFns, TGenerics['SortingFns']>
+        AggregationFns: IfDefined<TAggregationFns, TGenerics['AggregationFns']>
+      }
+    >
+  >
   createColumns: <TColumnDef extends ColumnDef<any>>(
     columns: TColumnDef[]
   ) => TColumnDef[]
@@ -95,39 +117,36 @@ export type Table<TGenerics extends AnyGenerics> = {
   ) => ColumnDef<TGenerics>
 }
 
-type InitTable<TRender extends AnyRender> = {
-  createTableFactory: <TGenerics extends AnyGenerics>(
-    options: CreateTableFactoryOptions<TRender, any, any, any>
-  ) => CreateTableFactory<Overwrite<TGenerics, { Render: TRender }>>
-  createTable: CreateTableFactory<
-    Overwrite<PartialGenerics, { Render: TRender }>
-  >
-}
-
 //
 
-export function init<TRender extends AnyRender>(opts: {
+export function createTableFactory<TRender extends AnyRender>(opts: {
   render: TRender
-}): InitTable<TRender> {
-  return {
-    createTableFactory: factoryOptions => () =>
-      _createTable(undefined, undefined, { ...factoryOptions, ...opts }),
-    createTable: () => _createTable(undefined, undefined, opts),
-  }
+}): () => Table<{ Render: TRender }> {
+  return () => createTable(undefined, undefined, opts)
 }
 
-function _createTable<TGenerics extends AnyGenerics>(
-  _: undefined,
-  __: undefined,
-  __options: CreateTableFactoryOptions<any, any, any, any>
+// A lot of returns in here are `as any` for a reason. Unless you
+// can find a better way to do this, then don't worry about them
+function createTable<TGenerics extends AnyGenerics>(
+  _?: undefined,
+  __?: undefined,
+  options?: CreateTableOptions<any, any, any, any, TGenerics>
 ): Table<TGenerics> {
-  return {
+  const table: Table<TGenerics> = {
     generics: undefined!,
-    __options: __options ?? {
-      render: () => {
-        throw new Error()
-      },
+    options: options ?? {
+      render: (() => {
+        throw new Error('')
+      })(),
     },
+    setRowType: () => table as any,
+    setTableMetaType: () => table as any,
+    setColumnMetaType: () => table as any,
+    setOptions: newOptions =>
+      createTable(_, __, {
+        ...options,
+        ...newOptions,
+      } as any),
     createColumns: columns => columns,
     createDisplayColumn: column => ({ ...column, columnDefType: 'display' }),
     createGroup: column => ({ ...column, columnDefType: 'group' } as any),
@@ -156,4 +175,6 @@ function _createTable<TGenerics extends AnyGenerics>(
       throw new Error('Invalid accessor')
     },
   }
+
+  return table
 }

package/src/features/Filters.ts

@@ -1,5 +1,5 @@
 import { RowModel } from '..'
-import { BuiltInFilterType, filterTypes } from '../filterTypes'
+import { BuiltInFilterType, filterFns } from '../filterFns'
 import {
   Column,
   OnChangeFn,
@@ -49,11 +49,11 @@ export type FiltersTableState = {
 export type FilterType<TGenerics extends AnyGenerics> =
   | 'auto'
   | BuiltInFilterType
-  | TGenerics['FilterFns']
+  | keyof TGenerics['FilterFns']
   | FilterFn<TGenerics>
 
 export type FiltersColumnDef<TGenerics extends AnyGenerics> = {
-  filterType?: FilterType<Overwrite<TGenerics, { Value: any }>>
+  filterFn?: FilterType<Overwrite<TGenerics, { Value: any }>>
   enableAllFilters?: boolean
   enableColumnFilter?: boolean
   enableGlobalFilter?: boolean
@@ -63,7 +63,7 @@ export type FiltersColumnDef<TGenerics extends AnyGenerics> = {
 }
 
 export type FiltersColumn<TGenerics extends AnyGenerics> = {
-  filterType: FilterType<Overwrite<TGenerics, { Value: any }>>
+  filterFn: FilterType<Overwrite<TGenerics, { Value: any }>>
   getCanColumnFilter: () => boolean
   getCanGlobalFilter: () => boolean
   getColumnFilterIndex: () => number
@@ -77,7 +77,7 @@ export type FiltersColumn<TGenerics extends AnyGenerics> = {
 
 export type FiltersOptions<TGenerics extends AnyGenerics> = {
   filterFromLeafRows?: boolean
-  filterTypes?: TGenerics['FilterFns']
+  filterFns?: TGenerics['FilterFns']
   enableFilters?: boolean
   // Column
   onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>
@@ -139,7 +139,7 @@ export const Filters = {
     TGenerics extends AnyGenerics
   >(): FiltersColumnDef<TGenerics> => {
     return {
-      filterType: 'auto',
+      filterFn: 'auto',
     }
   },
 
@@ -217,7 +217,7 @@ export const Filters = {
     )
 
     return {
-      filterType: column.filterType,
+      filterFn: column.filterFn,
       getCanColumnFilter: () => instance.getColumnCanColumnFilter(column.id),
       getCanGlobalFilter: () => instance.getColumnCanGlobalFilter(column.id),
       getColumnFilterIndex: () => instance.getColumnFilterIndex(column.id),
@@ -269,48 +269,48 @@ export const Filters = {
         const value = firstRow?.values[columnId]
 
         if (typeof value === 'string') {
-          return filterTypes.includesString
+          return filterFns.includesString
         }
 
         if (typeof value === 'number') {
-          return filterTypes.betweenNumberRange
+          return filterFns.betweenNumberRange
         }
 
         if (value !== null && typeof value === 'object') {
-          return filterTypes.equals
+          return filterFns.equals
         }
 
         if (Array.isArray(value)) {
-          return filterTypes.arrIncludes
+          return filterFns.arrIncludes
         }
 
-        return filterTypes.weakEquals
+        return filterFns.weakEquals
       },
       getGlobalAutoFilterFn: () => {
-        return filterTypes.includesString
+        return filterFns.includesString
       },
       getColumnFilterFn: columnId => {
         const column = instance.getColumn(columnId)
-        const userFilterTypes = instance.options.filterTypes
+        const userFilterTypes = instance.options.filterFns
 
         if (!column) {
           throw new Error()
         }
 
-        return isFunction(column.filterType)
-          ? column.filterType
-          : column.filterType === 'auto'
+        return isFunction(column.filterFn)
+          ? column.filterFn
+          : column.filterFn === 'auto'
           ? instance.getColumnAutoFilterFn(columnId)
           : (userFilterTypes as Record<string, any>)?.[
-              column.filterType as string
+              column.filterFn as string
             ] ??
-            (filterTypes[
-              column.filterType as BuiltInFilterType
+            (filterFns[
+              column.filterFn as BuiltInFilterType
             ] as FilterFn<TGenerics>)
       },
 
       getGlobalFilterFn: () => {
-        const { filterTypes: userFilterTypes, globalFilterType } =
+        const { filterFns: userFilterTypes, globalFilterType } =
           instance.options
 
         return isFunction(globalFilterType)
@@ -320,7 +320,7 @@ export const Filters = {
           : (userFilterTypes as Record<string, any>)?.[
               globalFilterType as string
             ] ??
-            (filterTypes[
+            (filterFns[
               globalFilterType as BuiltInFilterType
             ] as FilterFn<TGenerics>)
       },

package/src/features/Grouping.ts

@@ -1,5 +1,5 @@
 import { RowModel } from '..'
-import { BuiltInAggregationType, aggregationTypes } from '../aggregationTypes'
+import { BuiltInAggregationType, aggregationFns } from '../aggregationFns'
 import {
   Cell,
   Column,
@@ -46,7 +46,7 @@ export type GroupingTableState = {
 }
 
 export type GroupingColumnDef<TGenerics extends AnyGenerics> = {
-  aggregationType?: AggregationType<Overwrite<TGenerics, { Value: any }>>
+  aggregationFn?: AggregationType<Overwrite<TGenerics, { Value: any }>>
   aggregateValue?: (columnValue: unknown) => any
   aggregatedCell?: Renderable<
     TGenerics,
@@ -63,7 +63,7 @@ export type GroupingColumnDef<TGenerics extends AnyGenerics> = {
 }
 
 export type GroupingColumn<TGenerics extends AnyGenerics> = {
-  aggregationType?: AggregationType<Overwrite<TGenerics, { Value: any }>>
+  aggregationFn?: AggregationType<Overwrite<TGenerics, { Value: any }>>
   getCanGroup: () => boolean
   getIsGrouped: () => boolean
   getGroupedIndex: () => number
@@ -94,7 +94,7 @@ export type ColumnDefaultOptions = {
 }
 
 export type GroupingOptions<TGenerics extends AnyGenerics> = {
-  aggregationTypes?: TGenerics['AggregationFns']
+  aggregationFns?: TGenerics['AggregationFns']
   onGroupingChange?: OnChangeFn<GroupingState>
   autoResetGrouping?: boolean
   enableGrouping?: boolean
@@ -144,7 +144,7 @@ export const Grouping = {
     TGenerics extends AnyGenerics
   >(): GroupingColumnDef<TGenerics> => {
     return {
-      aggregationType: 'auto',
+      aggregationFn: 'auto',
     }
   },
 
@@ -169,7 +169,7 @@ export const Grouping = {
     instance: TableInstance<TGenerics>
   ): GroupingColumn<TGenerics> => {
     return {
-      aggregationType: column.aggregationType,
+      aggregationFn: column.aggregationFn,
       getCanGroup: () => instance.getColumnCanGroup(column.id),
       getGroupedIndex: () => instance.getColumnGroupedIndex(column.id),
       getIsGrouped: () => instance.getColumnIsGrouped(column.id),
@@ -210,32 +210,32 @@ export const Grouping = {
         const value = firstRow?.values[columnId]
 
         if (typeof value === 'number') {
-          return aggregationTypes.sum
+          return aggregationFns.sum
         }
 
         if (Object.prototype.toString.call(value) === '[object Date]') {
-          return aggregationTypes.extent
+          return aggregationFns.extent
         }
 
-        return aggregationTypes.count
+        return aggregationFns.count
       },
       getColumnAggregationFn: columnId => {
         const column = instance.getColumn(columnId)
-        const userAggregationTypes = instance.options.aggregationTypes
+        const userAggregationTypes = instance.options.aggregationFns
 
         if (!column) {
           throw new Error()
         }
 
-        return isFunction(column.aggregationType)
-          ? column.aggregationType
-          : column.aggregationType === 'auto'
+        return isFunction(column.aggregationFn)
+          ? column.aggregationFn
+          : column.aggregationFn === 'auto'
           ? instance.getColumnAutoAggregationFn(columnId)
           : (userAggregationTypes as Record<string, any>)?.[
-              column.aggregationType as string
+              column.aggregationFn as string
             ] ??
-            (aggregationTypes[
-              column.aggregationType as BuiltInAggregationType
+            (aggregationFns[
+              column.aggregationFn as BuiltInAggregationType
             ] as AggregationFn<TGenerics>)
       },
 

package/src/features/RowSelection.ts

@@ -591,7 +591,7 @@ export function selectRowsFn<TGenerics extends AnyGenerics>(
   const newSelectedRowsById: Record<string, Row<TGenerics>> = {}
 
   // Filters top level and nested rows
-  const recurseRows = (rows: Row<TGenerics>[], depth = 0) => {
+  const recurseRows = (rows: Row<TGenerics>[], depth = 0): Row<TGenerics>[] => {
     return rows
       .map(row => {
         const isSelected = isRowSelected(row, rowSelection, instance) === true

package/src/features/Sorting.ts

@@ -1,5 +1,5 @@
 import { RowModel } from '..'
-import { BuiltInSortType, reSplitAlphaNumeric, sortTypes } from '../sortTypes'
+import { BuiltInSortType, reSplitAlphaNumeric, sortingFns } from '../sortingFns'
 
 import {
   Column,
@@ -52,7 +52,7 @@ export type SortType<TGenerics extends AnyGenerics> =
   | SortingFn<TGenerics>
 
 export type SortingColumnDef<TGenerics extends AnyGenerics> = {
-  sortType?: SortType<Overwrite<TGenerics, { Value: any }>>
+  sortingFn?: SortType<Overwrite<TGenerics, { Value: any }>>
   sortDescFirst?: boolean
   enableSorting?: boolean
   enableMultiSort?: boolean
@@ -62,7 +62,7 @@ export type SortingColumnDef<TGenerics extends AnyGenerics> = {
 }
 
 export type SortingColumn<TGenerics extends AnyGenerics> = {
-  sortType: SortType<Overwrite<TGenerics, { Value: any }>>
+  sortingFn: SortType<Overwrite<TGenerics, { Value: any }>>
   getCanSort: () => boolean
   getCanMultiSort: () => boolean
   getSortIndex: () => number
@@ -75,7 +75,7 @@ export type SortingColumn<TGenerics extends AnyGenerics> = {
 }
 
 export type SortingOptions<TGenerics extends AnyGenerics> = {
-  sortTypes?: TGenerics['SortingFns']
+  sortingFns?: TGenerics['SortingFns']
   onSortingChange?: OnChangeFn<SortingState>
   autoResetSorting?: boolean
   enableSorting?: boolean
@@ -129,7 +129,7 @@ export const Sorting = {
     TGenerics extends AnyGenerics
   >(): SortingColumnDef<TGenerics> => {
     return {
-      sortType: 'auto',
+      sortingFn: 'auto',
     }
   },
 
@@ -156,7 +156,7 @@ export const Sorting = {
     instance: TableInstance<TGenerics>
   ): SortingColumn<TGenerics> => {
     return {
-      sortType: column.sortType,
+      sortingFn: column.sortingFn,
       getCanSort: () => instance.getColumnCanSort(column.id),
       getCanMultiSort: () => instance.getColumnCanMultiSort(column.id),
       getSortIndex: () => instance.getColumnSortIndex(column.id),
@@ -205,23 +205,23 @@ export const Sorting = {
           const value = row?.values[columnId]
 
           if (Object.prototype.toString.call(value) === '[object Date]') {
-            return sortTypes.datetime
+            return sortingFns.datetime
           }
 
           if (typeof value === 'string') {
             isString = true
 
             if (value.split(reSplitAlphaNumeric).length > 1) {
-              return sortTypes.alphanumeric
+              return sortingFns.alphanumeric
             }
           }
         }
 
         if (isString) {
-          return sortTypes.text
+          return sortingFns.text
         }
 
-        return sortTypes.basic
+        return sortingFns.basic
       },
       getColumnAutoSortDir: columnId => {
         const firstRow = instance.getGlobalFilteredRowModel().flatRows[0]
@@ -236,21 +236,21 @@ export const Sorting = {
       },
       getColumnSortingFn: columnId => {
         const column = instance.getColumn(columnId)
-        const userSortTypes = instance.options.sortTypes
+        const userSortTypes = instance.options.sortingFns
 
         if (!column) {
           throw new Error()
         }
 
-        return isFunction(column.sortType)
-          ? column.sortType
-          : column.sortType === 'auto'
+        return isFunction(column.sortingFn)
+          ? column.sortingFn
+          : column.sortingFn === 'auto'
           ? instance.getColumnAutoSortingFn(columnId)
           : (userSortTypes as Record<string, any>)?.[
-              column.sortType as string
+              column.sortingFn as string
             ] ??
-            (sortTypes[
-              column.sortType as BuiltInSortType
+            (sortingFns[
+              column.sortingFn as BuiltInSortType
             ] as SortingFn<TGenerics>)
       },
 

package/src/{filterTypes.ts → filterFns.ts}

@@ -1,6 +1,6 @@
 import { PartialGenerics, AnyGenerics, Row } from './types'
 
-export const filterTypes = {
+export const filterFns = {
   includesString,
   includesStringSensitive,
   equalsString,
@@ -12,7 +12,7 @@ export const filterTypes = {
   betweenNumberRange,
 }
 
-export type BuiltInFilterType = keyof typeof filterTypes
+export type BuiltInFilterType = keyof typeof filterFns
 
 function includesString<TGenerics extends AnyGenerics>(
   rows: Row<TGenerics>[],

package/src/{sortTypes.ts → sortingFns.ts}

@@ -2,7 +2,7 @@ import { PartialGenerics, AnyGenerics, Row } from './types'
 
 export const reSplitAlphaNumeric = /([0-9]+)/gm
 
-export const sortTypes = {
+export const sortingFns = {
   alphanumeric,
   alphanumericCaseSensitive,
   text,
@@ -11,7 +11,7 @@ export const sortTypes = {
   basic,
 }
 
-export type BuiltInSortType = keyof typeof sortTypes
+export type BuiltInSortType = keyof typeof sortingFns
 
 function alphanumeric<TGenerics extends AnyGenerics>(
   rowA: Row<TGenerics>,

package/src/utils/getColumnFilteredRowModelAsync.ts

@@ -12,7 +12,10 @@ export function getColumnFilteredRowModelAsync<
 }): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
   return instance =>
     incrementalMemo(
-      () => [instance.getState().columnFilters, instance.getCoreRowModel()],
+      () => [
+        instance.getState().columnFilters,
+        instance.getPreColumnFilteredRowModel(),
+      ],
       (_sorting, rowModel): RowModel<TGenerics> => {
         return {
           rows: rowModel.rows.slice(),
@@ -62,7 +65,7 @@ export function getColumnFilteredRowModelAsync<
         //       if (!filterFn) {
         //         if (process.env.NODE_ENV !== 'production') {
         //           console.warn(
-        //             `Could not find a valid 'column.filterType' for column with the ID: ${column.id}.`
+        //             `Could not find a valid 'column.filterFn' for column with the ID: ${column.id}.`
         //           )
         //         }
         //         continue

package/src/utils/getColumnFilteredRowModelSync.ts

@@ -10,10 +10,13 @@ export function getColumnFilteredRowModelSync<
 >(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
   return instance =>
     memo(
-      () => [instance.getState().columnFilters, instance.getCoreRowModel()],
+      () => [
+        instance.getState().columnFilters,
+        instance.getPreColumnFilteredRowModel(),
+      ],
       (columnFilters, rowModel) => {
         const columnFilteredRowModel: RowModel<TGenerics> = (() => {
-          if (!rowModel.rows.length || !columnFilters) {
+          if (!rowModel.rows.length || !columnFilters?.length) {
             return rowModel
           }
 
@@ -47,7 +50,7 @@ export function getColumnFilteredRowModelSync<
               if (!filterFn) {
                 if (process.env.NODE_ENV !== 'production') {
                   console.warn(
-                    `Could not find a valid 'column.filterType' for column with the ID: ${column.id}.`
+                    `Could not find a valid 'column.filterFn' for column with the ID: ${column.id}.`
                   )
                 }
                 continue

package/src/utils/getExpandedRowModel.ts

@@ -8,7 +8,7 @@ export function getExpandedRowModel<TGenerics extends AnyGenerics>(): (
     memo(
       () => [
         instance.getState().expanded,
-        instance.getGroupedRowModel(),
+        instance.getPreExpandedRowModel(),
         instance.options.paginateExpandedRows,
       ],
       (expanded, rowModel, paginateExpandedRows) => {

package/src/utils/getGlobalFilteredRowModelAsync.ts

@@ -12,7 +12,10 @@ export function getGlobalFilteredRowModelAsync<
 }): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
   return instance =>
     incrementalMemo(
-      () => [instance.getState().globalFilter, instance.getCoreRowModel()],
+      () => [
+        instance.getState().globalFilter,
+        instance.getPreGlobalFilteredRowModel(),
+      ],
       (_globalFilter, rowModel): RowModel<TGenerics> => {
         return {
           rows: rowModel.rows.slice(),

package/src/utils/getGlobalFilteredRowModelSync.ts

@@ -10,7 +10,10 @@ export function getGlobalFilteredRowModelSync<
 >(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
   return instance =>
     memo(
-      () => [instance.getState().globalFilter, instance.getCoreRowModel()],
+      () => [
+        instance.getState().globalFilter,
+        instance.getPreGlobalFilteredRowModel(),
+      ],
       (globalFilter, rowModel) => {
         const globalFilteredRowModel: RowModel<TGenerics> = (() => {
           if (!rowModel.rows.length || !globalFilter) {