@tanstack/table-core 9.0.0-beta.1 → 9.0.0-beta.11

package/src/features/row-pagination/rowPaginationFeature.types.ts

@@ -42,8 +42,8 @@ export interface PaginationDefaultOptions {
 }
 
 export interface Table_RowPagination<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   _autoResetPageIndex: () => void
   /**
@@ -117,8 +117,8 @@ export interface Table_RowPagination<
 }
 
 export interface Table_RowModels_Paginated<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Resolves the row model after pagination has sliced the current page.
@@ -130,23 +130,9 @@ export interface Table_RowModels_Paginated<
   getPrePaginatedRowModel: () => RowModel<TFeatures, TData>
 }
 
-export interface CreateRowModel_Paginated<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * Factory used to retrieve the paginated row model. If using server-side
-   * pagination, this is not required. To use client-side pagination, pass
-   * `createPaginatedRowModel()` or implement your own factory.
-   */
-  paginatedRowModel?: (
-    table: Table<TFeatures, TData>,
-  ) => () => RowModel<TFeatures, TData>
-}
-
 export interface CachedRowModel_Paginated<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   paginatedRowModel: () => RowModel<TFeatures, TData>
 }

package/src/features/row-pinning/rowPinningFeature.ts

@@ -16,114 +16,82 @@ import {
   table_resetRowPinning,
   table_setRowPinning,
 } from './rowPinningFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type {
-//   Row_RowPinning,
-//   TableOptions_RowPinning,
-//   TableState_RowPinning,
-//   Table_RowPinning,
-// } from './rowPinningFeature.types'
-
-export interface RowPinningFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // Row: Row_RowPinning
-  // Table: Table_RowPinning<TFeatures, RowData>
-  // TableOptions: TableOptions_RowPinning<TFeatures, RowData>
-  // TableState: TableState_RowPinning
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock row pinning feature.
- *
- * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ * Feature that adds row pinning state and APIs for top, center, and bottom rows.
  */
-export function constructRowPinningFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<RowPinningFeatureConstructors<TFeatures, TData>> {
-  return {
-    getInitialState: (initialState) => {
-      return {
-        ...initialState,
-        rowPinning: {
-          ...getDefaultRowPinningState(),
-          ...initialState.rowPinning,
-        },
-      }
-    },
+export const rowPinningFeature: TableFeature = {
+  getInitialState: (initialState) => {
+    return {
+      ...initialState,
+      rowPinning: {
+        ...getDefaultRowPinningState(),
+        ...initialState.rowPinning,
+      },
+    }
+  },
 
-    getDefaultTableOptions: (table) => {
-      return {
-        onRowPinningChange: makeStateUpdater('rowPinning', table),
-      }
-    },
+  getDefaultTableOptions: (table) => {
+    return {
+      onRowPinningChange: makeStateUpdater('rowPinning', table),
+    }
+  },
 
-    assignRowPrototype: (prototype, table) => {
-      assignPrototypeAPIs('rowPinningFeature', prototype, table, {
-        row_getCanPin: {
-          fn: (row) => row_getCanPin(row),
-        },
-        row_getIsPinned: {
-          fn: (row) => row_getIsPinned(row),
-        },
-        row_getPinnedIndex: {
-          fn: (row) => row_getPinnedIndex(row),
-          memoDeps: (row) => [
-            row.table.getRowModel().rows,
-            row.table.atoms.rowPinning?.get(),
-          ],
-        },
-        row_pin: {
-          fn: (row, position, includeLeafRows, includeParentRows) =>
-            row_pin(row, position, includeLeafRows, includeParentRows),
-        },
-      })
-    },
+  assignRowPrototype: (prototype, table) => {
+    assignPrototypeAPIs('rowPinningFeature', prototype, table, {
+      row_getCanPin: {
+        fn: (row) => row_getCanPin(row),
+      },
+      row_getIsPinned: {
+        fn: (row) => row_getIsPinned(row),
+      },
+      row_getPinnedIndex: {
+        fn: (row) => row_getPinnedIndex(row),
+        memoDeps: (row) => [
+          row.table.getRowModel().rows,
+          row.table.atoms.rowPinning?.get(),
+        ],
+      },
+      row_pin: {
+        fn: (row, position, includeLeafRows, includeParentRows) =>
+          row_pin(row, position, includeLeafRows, includeParentRows),
+      },
+    })
+  },
 
-    constructTableAPIs: (table) => {
-      assignTableAPIs('rowPinningFeature', table, {
-        table_setRowPinning: {
-          fn: (updater) => table_setRowPinning(table, updater),
-        },
-        table_resetRowPinning: {
-          fn: (defaultState) => table_resetRowPinning(table, defaultState),
-        },
-        table_getIsSomeRowsPinned: {
-          fn: (position) => table_getIsSomeRowsPinned(table, position),
-        },
-        table_getTopRows: {
-          fn: () => table_getTopRows(table),
-          memoDeps: () => [
-            table.getRowModel().rows,
-            table.atoms.rowPinning?.get()?.top,
-          ],
-        },
-        table_getBottomRows: {
-          fn: () => table_getBottomRows(table),
-          memoDeps: () => [
-            table.getRowModel().rows,
-            table.atoms.rowPinning?.get()?.bottom,
-          ],
-        },
-        table_getCenterRows: {
-          fn: () => table_getCenterRows(table),
-          memoDeps: () => [
-            table.getRowModel().rows,
-            table.atoms.rowPinning?.get(),
-          ],
-        },
-      })
-    },
-  }
+  constructTableAPIs: (table) => {
+    assignTableAPIs('rowPinningFeature', table, {
+      table_setRowPinning: {
+        fn: (updater) => table_setRowPinning(table, updater),
+      },
+      table_resetRowPinning: {
+        fn: (defaultState) => table_resetRowPinning(table, defaultState),
+      },
+      table_getIsSomeRowsPinned: {
+        fn: (position) => table_getIsSomeRowsPinned(table, position),
+      },
+      table_getTopRows: {
+        fn: () => table_getTopRows(table),
+        memoDeps: () => [
+          table.getRowModel().rows,
+          table.atoms.rowPinning?.get()?.top,
+        ],
+      },
+      table_getBottomRows: {
+        fn: () => table_getBottomRows(table),
+        memoDeps: () => [
+          table.getRowModel().rows,
+          table.atoms.rowPinning?.get()?.bottom,
+        ],
+      },
+      table_getCenterRows: {
+        fn: () => table_getCenterRows(table),
+        memoDeps: () => [
+          table.getRowModel().rows,
+          table.atoms.rowPinning?.get(),
+        ],
+      },
+    })
+  },
 }
-
-/**
- * The stock row pinning feature.
- *
- * Register this feature to add row pinning state and APIs for deriving top,
- * center, and bottom row regions.
- */
-export const rowPinningFeature = constructRowPinningFeature()

package/src/features/row-pinning/rowPinningFeature.types.ts

@@ -14,8 +14,8 @@ export interface TableState_RowPinning {
 }
 
 export interface TableOptions_RowPinning<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Allows rows to be pinned to top or bottom regions.
@@ -63,8 +63,8 @@ export interface Row_RowPinning {
 }
 
 export interface Table_RowPinning<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Gets rows pinned to the bottom region.

package/src/features/row-selection/rowSelectionFeature.ts

@@ -28,145 +28,113 @@ import {
   table_toggleAllPageRowsSelected,
   table_toggleAllRowsSelected,
 } from './rowSelectionFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type {
-//   Row_RowSelection,
-//   TableOptions_RowSelection,
-//   TableState_RowSelection,
-//   Table_RowSelection,
-// } from './rowSelectionFeature.types'
-
-export interface RowSelectionFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // Row: Row_RowSelection
-  // Table: Table_RowSelection<TFeatures, TData>
-  // TableOptions: TableOptions_RowSelection<TFeatures, TData>
-  // TableState: TableState_RowSelection
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock row selection feature.
- *
- * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ * Feature that adds row selection state and APIs for row and page selection.
  */
-export function constructRowSelectionFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<RowSelectionFeatureConstructors<TFeatures, TData>> {
-  return {
-    getInitialState: (initialState) => {
-      return {
-        rowSelection: getDefaultRowSelectionState(),
-        ...initialState,
-      }
-    },
+export const rowSelectionFeature: TableFeature = {
+  getInitialState: (initialState) => {
+    return {
+      rowSelection: getDefaultRowSelectionState(),
+      ...initialState,
+    }
+  },
 
-    getDefaultTableOptions: (table) => {
-      return {
-        onRowSelectionChange: makeStateUpdater('rowSelection', table),
-        enableRowSelection: true,
-        enableMultiRowSelection: true,
-        enableSubRowSelection: true,
-      }
-    },
+  getDefaultTableOptions: (table) => {
+    return {
+      onRowSelectionChange: makeStateUpdater('rowSelection', table),
+      enableRowSelection: true,
+      enableMultiRowSelection: true,
+      enableSubRowSelection: true,
+    }
+  },
 
-    assignRowPrototype: (prototype, table) => {
-      assignPrototypeAPIs('rowSelectionFeature', prototype, table, {
-        row_toggleSelected: {
-          fn: (row, value, opts) => row_toggleSelected(row, value, opts),
-        },
-        row_getIsSelected: {
-          fn: (row) => row_getIsSelected(row),
-        },
-        row_getIsSomeSelected: {
-          fn: (row) => row_getIsSomeSelected(row),
-        },
-        row_getIsAllSubRowsSelected: {
-          fn: (row) => row_getIsAllSubRowsSelected(row),
-        },
-        row_getCanSelect: {
-          fn: (row) => row_getCanSelect(row),
-        },
-        row_getCanSelectSubRows: {
-          fn: (row) => row_getCanSelectSubRows(row),
-        },
-        row_getCanMultiSelect: {
-          fn: (row) => row_getCanMultiSelect(row),
-        },
-        row_getToggleSelectedHandler: {
-          fn: (row) => row_getToggleSelectedHandler(row),
-        },
-      })
-    },
+  assignRowPrototype: (prototype, table) => {
+    assignPrototypeAPIs('rowSelectionFeature', prototype, table, {
+      row_toggleSelected: {
+        fn: (row, value, opts) => row_toggleSelected(row, value, opts),
+      },
+      row_getIsSelected: {
+        fn: (row) => row_getIsSelected(row),
+      },
+      row_getIsSomeSelected: {
+        fn: (row) => row_getIsSomeSelected(row),
+      },
+      row_getIsAllSubRowsSelected: {
+        fn: (row) => row_getIsAllSubRowsSelected(row),
+      },
+      row_getCanSelect: {
+        fn: (row) => row_getCanSelect(row),
+      },
+      row_getCanSelectSubRows: {
+        fn: (row) => row_getCanSelectSubRows(row),
+      },
+      row_getCanMultiSelect: {
+        fn: (row) => row_getCanMultiSelect(row),
+      },
+      row_getToggleSelectedHandler: {
+        fn: (row) => row_getToggleSelectedHandler(row),
+      },
+    })
+  },
 
-    constructTableAPIs: (table) => {
-      assignTableAPIs('rowSelectionFeature', table, {
-        table_setRowSelection: {
-          fn: (updater) => table_setRowSelection(table, updater),
-        },
-        table_resetRowSelection: {
-          fn: (defaultState) => table_resetRowSelection(table, defaultState),
-        },
-        table_toggleAllRowsSelected: {
-          fn: (value) => table_toggleAllRowsSelected(table, value),
-        },
-        table_toggleAllPageRowsSelected: {
-          fn: (value) => table_toggleAllPageRowsSelected(table, value),
-        },
-        table_getPreSelectedRowModel: {
-          fn: () => table_getPreSelectedRowModel(table),
-        },
-        table_getSelectedRowModel: {
-          fn: () => table_getSelectedRowModel(table),
-          memoDeps: () => [
-            table.atoms.rowSelection?.get(),
-            table.getCoreRowModel(),
-          ],
-        },
-        table_getFilteredSelectedRowModel: {
-          fn: () => table_getFilteredSelectedRowModel(table),
-          memoDeps: () => [
-            table.atoms.rowSelection?.get(),
-            table.getFilteredRowModel(),
-          ],
-        },
-        table_getGroupedSelectedRowModel: {
-          fn: () => table_getGroupedSelectedRowModel(table),
-          memoDeps: () => [
-            table.atoms.rowSelection?.get(),
-            table.getSortedRowModel(),
-          ],
-        },
-        table_getIsAllRowsSelected: {
-          fn: () => table_getIsAllRowsSelected(table),
-        },
-        table_getIsAllPageRowsSelected: {
-          fn: () => table_getIsAllPageRowsSelected(table),
-        },
-        table_getIsSomeRowsSelected: {
-          fn: () => table_getIsSomeRowsSelected(table),
-        },
-        table_getIsSomePageRowsSelected: {
-          fn: () => table_getIsSomePageRowsSelected(table),
-        },
-        table_getToggleAllRowsSelectedHandler: {
-          fn: () => table_getToggleAllRowsSelectedHandler(table),
-        },
-        table_getToggleAllPageRowsSelectedHandler: {
-          fn: () => table_getToggleAllPageRowsSelectedHandler(table),
-        },
-      })
-    },
-  }
+  constructTableAPIs: (table) => {
+    assignTableAPIs('rowSelectionFeature', table, {
+      table_setRowSelection: {
+        fn: (updater) => table_setRowSelection(table, updater),
+      },
+      table_resetRowSelection: {
+        fn: (defaultState) => table_resetRowSelection(table, defaultState),
+      },
+      table_toggleAllRowsSelected: {
+        fn: (value) => table_toggleAllRowsSelected(table, value),
+      },
+      table_toggleAllPageRowsSelected: {
+        fn: (value) => table_toggleAllPageRowsSelected(table, value),
+      },
+      table_getPreSelectedRowModel: {
+        fn: () => table_getPreSelectedRowModel(table),
+      },
+      table_getSelectedRowModel: {
+        fn: () => table_getSelectedRowModel(table),
+        memoDeps: () => [
+          table.atoms.rowSelection?.get(),
+          table.getCoreRowModel(),
+        ],
+      },
+      table_getFilteredSelectedRowModel: {
+        fn: () => table_getFilteredSelectedRowModel(table),
+        memoDeps: () => [
+          table.atoms.rowSelection?.get(),
+          table.getFilteredRowModel(),
+        ],
+      },
+      table_getGroupedSelectedRowModel: {
+        fn: () => table_getGroupedSelectedRowModel(table),
+        memoDeps: () => [
+          table.atoms.rowSelection?.get(),
+          table.getSortedRowModel(),
+        ],
+      },
+      table_getIsAllRowsSelected: {
+        fn: () => table_getIsAllRowsSelected(table),
+      },
+      table_getIsAllPageRowsSelected: {
+        fn: () => table_getIsAllPageRowsSelected(table),
+      },
+      table_getIsSomeRowsSelected: {
+        fn: () => table_getIsSomeRowsSelected(table),
+      },
+      table_getIsSomePageRowsSelected: {
+        fn: () => table_getIsSomePageRowsSelected(table),
+      },
+      table_getToggleAllRowsSelectedHandler: {
+        fn: () => table_getToggleAllRowsSelectedHandler(table),
+      },
+      table_getToggleAllPageRowsSelectedHandler: {
+        fn: () => table_getToggleAllPageRowsSelectedHandler(table),
+      },
+    })
+  },
 }
-
-/**
- * The stock row selection feature.
- *
- * Register this feature to add row selection state, selected row-model helpers,
- * and table/row APIs for checkbox and bulk-selection UI.
- */
-export const rowSelectionFeature = constructRowSelectionFeature()

package/src/features/row-selection/rowSelectionFeature.types.ts

@@ -10,8 +10,8 @@ export interface TableState_RowSelection {
 }
 
 export interface TableOptions_RowSelection<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Allows rows to be selected alongside other rows.
@@ -87,8 +87,8 @@ export interface Row_RowSelection {
 }
 
 export interface Table_RowSelection<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Builds a selected-row model from rows after filtering.

package/src/features/row-selection/rowSelectionFeature.utils.ts

@@ -649,7 +649,7 @@ export function selectRowsFn<
   ): Array<Row<TFeatures, TData>> => {
     const result: Array<Row<TFeatures, TData>> = []
     for (let i = 0; i < rows.length; i++) {
-      let row = rows[i]!
+      const row = rows[i]!
       const isSelected = isRowSelected(row)
 
       if (isSelected) {
@@ -658,13 +658,18 @@ export function selectRowsFn<
       }
 
       if (row.subRows.length) {
-        row = {
-          ...row,
-          subRows: recurseRows(row.subRows, depth + 1),
+        // Always recurse — selected descendants of unselected parents must
+        // still be collected into flatRows/rowsById.
+        const newSubRows = recurseRows(row.subRows, depth + 1)
+
+        if (isSelected) {
+          // Preserve prototype chain so methods like getValue() remain accessible
+          const cloned = Object.create(Object.getPrototypeOf(row))
+          Object.assign(cloned, row)
+          cloned.subRows = newSubRows
+          result.push(cloned)
         }
-      }
-
-      if (isSelected) {
+      } else if (isSelected) {
         result.push(row)
       }
     }

package/src/features/row-sorting/createSortedRowModel.ts

@@ -6,23 +6,23 @@ 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, SortFns } from './rowSortingFeature.types'
+import type { SortFn } from './rowSortingFeature.types'
 import type { RowData } from '../../types/type-utils'
 
 /**
  * Creates a memoized sorted row model factory.
  *
  * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
+ *
+ * Register sorting functions with the `sortFns` slot on the `features` option:
+ * `tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns })`.
  */
 export function createSortedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
->(
-  sortFns: Record<keyof SortFns, SortFn<TFeatures, TData>>,
-): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {
+>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {
   return (_table) => {
-    const table: Table_Internal<TFeatures, TData> = _table
-    if (!table._rowModelFns.sortFns) table._rowModelFns.sortFns = sortFns
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     return tableMemo({
       feature: 'rowSortingFeature',
       table,