feat: Beta

packages/react-table/package.json

@@ -49,8 +49,7 @@
     "build": "tsdown"
   },
   "dependencies": {
-    "@tanstack/react-store": "^0.11.1",
-    "@tanstack/table-core": "workspace:*"
+    "@tanstack/react-store": "^0.11.1"
   },
   "devDependencies": {
     "@eslint-react/eslint-plugin": "^5.18.1",
@@ -61,9 +60,11 @@
     "eslint-plugin-react-compiler": "19.1.0-rc.2",
     "eslint-plugin-react-hooks": "^7.1.1",
     "react": "^19.2.8",
-    "react-dom": "^19.2.8"
+    "react-dom": "^19.2.8",
+    "@tanstack/table-core": "workspace:*"
   },
   "peerDependencies": {
-    "react": ">=18"
+    "react": ">=18",
+    "@tanstack/table-core": "9.0.0-beta.80"
   }
 }

packages/table-core/src/features/column-filtering/createFilteredRowModel.ts

@@ -13,6 +13,7 @@ import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
 import type { Table, Table_Internal } from '../../types/Table'
 import type { Row } from '../../types/Row'
 import type {
+  ColumnFiltersState,
   ResolvedColumnFilter,
   Row_ColumnFiltering,
 } from './columnFilteringFeature.types'
@@ -44,19 +45,37 @@ export function createFilteredRowModel<
         table.atoms.columnFilters?.get(),
         table.atoms.globalFilter?.get(),
       ],
-      fn: () => _createFilteredRowModel(table),
+      fn: () =>
+        createFilteredRowModelUnmemoized(
+          table,
+          table.atoms.columnFilters?.get(),
+          table.atoms.globalFilter?.get(),
+          table.getPreFilteredRowModel(),
+        ),
       onAfterUpdate: skipFirstRun(() => table_autoResetPageIndex(table)),
     })
   }
 }
 
-function _createFilteredRowModel<
+/**
+ * Pure, unmemoized filtering pass: filters `rowModel` by `columnFilters` and
+ * `globalFilter`, without reading any of them off `table` (i.e. it does not
+ * call `table.getPreFilteredRowModel()` or `table.atoms.columnFilters?.get()` /
+ * `table.atoms.globalFilter?.get()` itself). This lets callers re-run
+ * filtering with a row model, column filters, or global filter of their own
+ * choosing outside of `table`'s normal row-model pipeline — for example to
+ * decide, from within a custom `filteredRowModel` feature, what the "real"
+ * (non-custom) filtered result would have been.
+ */
+export function createFilteredRowModelUnmemoized<
   TFeatures extends TableFeatures,
   TData extends RowData = any,
->(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  const rowModel = table.getPreFilteredRowModel()
-  const columnFilters = table.atoms.columnFilters?.get()
-  const globalFilter = table.atoms.globalFilter?.get()
+>(
+  table: Table_Internal<TFeatures, TData>,
+  columnFilters: ColumnFiltersState | undefined,
+  globalFilter: unknown,
+  rowModel: RowModel<TFeatures, TData>,
+): RowModel<TFeatures, TData> {
   const hasGlobalFilter =
     globalFilter !== undefined && globalFilter !== null && globalFilter !== ''
 

packages/table-core/src/features/column-grouping/createGroupedRowModel.ts

@@ -7,7 +7,10 @@ import {
   aggregateColumnValue,
   normalizeUniqueAggregationRows,
 } from '../row-aggregation/rowAggregationFeature.utils'
-import type { Row_ColumnGrouping } from './columnGroupingFeature.types'
+import type {
+  GroupingState,
+  Row_ColumnGrouping,
+} from './columnGroupingFeature.types'
 import type { Column_Internal } from '../../types/Column'
 import type { TableFeatures } from '../../types/TableFeatures'
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
@@ -42,7 +45,12 @@ export function createGroupedRowModel<
         table.getPreGroupedRowModel(),
         table.options.columns,
       ],
-      fn: () => _createGroupedRowModel(table),
+      fn: () =>
+        createGroupedRowModelUnmemoized(
+          table,
+          table.atoms.grouping?.get(),
+          table.getPreGroupedRowModel(),
+        ),
       onAfterUpdate: () => {
         const grouping = table.atoms.grouping?.get()
         const preGroupedRowModel = table.getPreGroupedRowModel()
@@ -70,13 +78,22 @@ export function createGroupedRowModel<
   }
 }
 
-function _createGroupedRowModel<
+/**
+ * Pure, unmemoized grouping pass: groups `rowModel` by `grouping` without reading
+ * either off `table` (i.e. it does not call `table.getPreGroupedRowModel()` or
+ * `table.atoms.grouping?.get()` itself). This lets callers re-run grouping on a
+ * row model of their own choosing outside of `table`'s normal row-model
+ * pipeline — for example to preview the grouped order of a differently-filtered
+ * row model before deciding what `table.getFilteredRowModel()` should return.
+ */
+export function createGroupedRowModelUnmemoized<
   TFeatures extends TableFeatures,
   TData extends RowData = any,
->(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  const rowModel = table.getPreGroupedRowModel()
-  const grouping = table.atoms.grouping?.get()
-
+>(
+  table: Table_Internal<TFeatures, TData>,
+  grouping: GroupingState | undefined,
+  rowModel: RowModel<TFeatures, TData>,
+): RowModel<TFeatures, TData> {
   if (!rowModel.rows.length || !grouping?.length) {
     // A previous grouped pass rewrote depth/parentId on these shared row
     // objects, shifting the whole tree down by the number of grouping levels.

packages/table-core/src/features/row-sorting/createSortedRowModel.ts

@@ -10,7 +10,7 @@ import type { TableFeatures } from '../../types/TableFeatures'
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
 import type { Table, Table_Internal } from '../../types/Table'
 import type { Row } from '../../types/Row'
-import type { SortFn } from './rowSortingFeature.types'
+import type { SortFn, SortingState } from './rowSortingFeature.types'
 import type { RowData } from '../../types/type-utils'
 
 /**
@@ -39,19 +39,34 @@ export function createSortedRowModel<
         table.atoms.sorting?.get(),
         table.getPreSortedRowModel(),
       ],
-      fn: () => _createSortedRowModel(table),
+      fn: () =>
+        createSortedRowModelUnmemoized(
+          table,
+          table.atoms.sorting?.get(),
+          table.getPreSortedRowModel(),
+        ),
       onAfterUpdate: skipFirstRun(() => table_autoResetPageIndex(table)),
     })
   }
 }
 
-function _createSortedRowModel<
+/**
+ * Pure, unmemoized sorting pass: sorts `preSortedRowModel` (recursing into
+ * `subRows` per group) by `sorting`, without reading either off `table` (i.e.
+ * it does not call `table.getPreSortedRowModel()` or `table.atoms.sorting?.get()`
+ * itself). This lets callers re-run sorting on a row model of their own
+ * choosing outside of `table`'s normal row-model pipeline — for example to
+ * preview the sorted order of a differently-filtered row model before
+ * deciding what `table.getFilteredRowModel()` should return.
+ */
+export function createSortedRowModelUnmemoized<
   TFeatures extends TableFeatures,
   TData extends RowData = any,
->(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  const preSortedRowModel = table.getPreSortedRowModel()
-  const sorting = table.atoms.sorting?.get()
-
+>(
+  table: Table_Internal<TFeatures, TData>,
+  sorting: SortingState | undefined,
+  preSortedRowModel: RowModel<TFeatures, TData>,
+): RowModel<TFeatures, TData> {
   if (!preSortedRowModel.rows.length || !sorting?.length) {
     return preSortedRowModel
   }

packages/table-core/src/index.ts

@@ -89,6 +89,7 @@ export * from './features/column-filtering/columnFilteringFeature'
 export * from './features/column-filtering/columnFilteringFeature.types'
 export * from './features/column-filtering/createFilteredRowModel'
 export * from './features/column-filtering/filterFns'
+export * from './features/column-filtering/filterRowsUtils'
 
 // columnGroupingFeature
 export * from './features/column-grouping/columnGroupingFeature'