@tanstack/table-core 9.0.0-beta.2 → 9.0.0-beta.20

package/src/features/column-filtering/columnFilteringFeature.types.ts

@@ -1,4 +1,3 @@
-import type { Table } from '../../types/Table'
 import type { BuiltInFilterFn } from '../../fns/filterFns'
 import type {
   CellData,
@@ -6,13 +5,28 @@ import type {
   RowData,
   Updater,
 } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
+import type { IsAny, TableFeatures } from '../../types/TableFeatures'
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
 import type { Row } from '../../types/Row'
 import type { Column } from '../../types/Column'
 
 export interface FilterMeta {}
 
+/**
+ * Resolves the type of the filter meta attached to rows for a feature set.
+ *
+ * When the features object declares a `filterMeta` type-only slot
+ * (`tableFeatures({ ..., filterMeta: {} as MyFilterMeta })`), that type wins.
+ * Otherwise this falls back to the global declaration-merged `FilterMeta`
+ * interface.
+ */
+export type ExtractFilterMeta<TFeatures extends TableFeatures> =
+  IsAny<TFeatures> extends true
+    ? FilterMeta
+    : TFeatures extends { filterMeta: infer TFilterMeta extends object }
+      ? TFilterMeta
+      : FilterMeta
+
 export interface FilterFns {}
 
 export interface TableState_ColumnFiltering {
@@ -27,8 +41,8 @@ export interface ColumnFilter {
 }
 
 export interface ResolvedColumnFilter<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   filterFn: FilterFn<TFeatures, TData>
   id: string
@@ -36,21 +50,21 @@ export interface ResolvedColumnFilter<
 }
 
 export interface RowModelFns_ColumnFiltering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
-  filterFns: Record<keyof FilterFns, FilterFn<TFeatures, TData>>
+  filterFns: Record<string, FilterFn<TFeatures, TData>>
 }
 
 export interface FilterFn<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   (
     row: Row<TFeatures, TData>,
     columnId: string,
     filterValue: any,
-    addMeta?: (meta: FilterMeta) => void,
+    addMeta?: (meta: ExtractFilterMeta<TFeatures>) => void,
   ): boolean
   autoRemove?: ColumnFilterAutoRemoveTestFn<TFeatures, TData>
   resolveFilterValue?: TransformFilterValueFn<TFeatures, TData>
@@ -73,14 +87,31 @@ export type CustomFilterFns<
   TData extends RowData,
 > = Record<string, FilterFn<TFeatures, TData>>
 
+/**
+ * Resolves the valid string names for `columnDef.filterFn` and
+ * `options.globalFilterFn` for a feature set.
+ *
+ * When the features object declares a `filterFns` registry
+ * (`tableFeatures({ ..., filterFns })`), its keys are the only valid names; a
+ * name is only assignable if a filter function is actually registered for it.
+ * Otherwise this falls back to the global declaration-merged `FilterFns`
+ * interface.
+ */
+export type ExtractFilterFnKeys<TFeatures extends TableFeatures> =
+  IsAny<TFeatures> extends true
+    ? keyof FilterFns | BuiltInFilterFn
+    : TFeatures extends { filterFns: infer TFilterFns extends object }
+      ? Extract<keyof TFilterFns, string>
+      : keyof FilterFns
+
 export type FilterFnOption<
   TFeatures extends TableFeatures,
   TData extends RowData,
-> = 'auto' | BuiltInFilterFn | keyof FilterFns | FilterFn<TFeatures, TData>
+> = 'auto' | ExtractFilterFnKeys<TFeatures> | FilterFn<TFeatures, TData>
 
 export interface ColumnDef_ColumnFiltering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Enables this column to participate in column-specific filtering.
@@ -96,8 +127,8 @@ export interface ColumnDef_ColumnFiltering<
 }
 
 export interface Column_ColumnFiltering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Returns an automatically calculated filter function for the column based off of the columns first known value.
@@ -133,8 +164,8 @@ export interface Column_ColumnFiltering<
 }
 
 export interface Row_ColumnFiltering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * The column filters map for the row. This object tracks whether a row is passing/failing specific filters by their column ID.
@@ -143,12 +174,12 @@ export interface Row_ColumnFiltering<
   /**
    * The column filters meta map for the row. This object tracks any filter meta for a row as optionally provided during the filtering process.
    */
-  columnFiltersMeta: Record<string, FilterMeta>
+  columnFiltersMeta: Record<string, ExtractFilterMeta<TFeatures>>
 }
 
 export interface TableOptions_ColumnFiltering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Enables column-specific filtering for all columns that also allow it.
@@ -196,8 +227,8 @@ export interface Table_ColumnFiltering {
 }
 
 export interface Table_RowModels_Filtered<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Resolves the row model after column and global filters have been applied.
@@ -209,24 +240,9 @@ export interface Table_RowModels_Filtered<
   getPreFilteredRowModel: () => RowModel<TFeatures, TData>
 }
 
-export interface CreateRowModel_Filtered<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * If provided, this factory is called once per table and should return a
-   * function that calculates the filtered row model.
-   * - For server-side filtering, this function is unnecessary and can be ignored since the server should already return the filtered row model.
-   * - For client-side filtering, pass the exported `createFilteredRowModel()` or implement your own factory.
-   */
-  filteredRowModel?: (
-    table: Table<TFeatures, TData>,
-  ) => () => RowModel<TFeatures, TData>
-}
-
 export interface CachedRowModel_Filtered<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   filteredRowModel: () => RowModel<TFeatures, TData>
 }

package/src/features/column-filtering/columnFilteringFeature.utils.ts

@@ -104,7 +104,7 @@ export function column_getFilterFn<
     )
   }
 
-  return filterFn
+  return filterFn ?? undefined
 }
 
 /**
@@ -323,7 +323,7 @@ export function shouldAutoRemoveFilter<
 ) {
   return (
     (filterFn && filterFn.autoRemove
-      ? filterFn.autoRemove(value, column)
+      ? filterFn.autoRemove(value, column as any)
       : false) ||
     typeof value === 'undefined' ||
     (typeof value === 'string' && !value)

package/src/features/column-filtering/createFilteredRowModel.ts

@@ -1,4 +1,4 @@
-import { tableMemo } from '../../utils'
+import { makeObjectMap, tableMemo } from '../../utils'
 import { table_getColumn } from '../../core/columns/coreColumnsFeature.utils'
 import {
   column_getCanGlobalFilter,
@@ -13,8 +13,6 @@ 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 {
-  FilterFn,
-  FilterFns,
   ResolvedColumnFilter,
   Row_ColumnFiltering,
 } from './columnFilteringFeature.types'
@@ -23,16 +21,16 @@ import type {
  * Creates a memoized filtered 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 filter functions with the `filterFns` slot on the `features` option:
+ * `tableFeatures({ columnFilteringFeature, filteredRowModel: createFilteredRowModel(), filterFns })`.
  */
 export function createFilteredRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData = any,
->(
-  filterFns: Record<keyof FilterFns, FilterFn<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.filterFns) table._rowModelFns.filterFns = filterFns
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     return tableMemo({
       feature: 'columnFilteringFeature',
       table,
@@ -62,8 +60,8 @@ function _createFilteredRowModel<
     >
     for (let i = 0; i < flatRows.length; i++) {
       const row = flatRows[i]!
-      row.columnFilters = {}
-      row.columnFiltersMeta = {}
+      row.columnFilters = makeObjectMap()
+      row.columnFiltersMeta = makeObjectMap()
     }
     return rowModel
   }
@@ -117,7 +115,8 @@ function _createFilteredRowModel<
   >
   for (let i = 0; i < flatRows.length; i++) {
     const row = flatRows[i]!
-    row.columnFilters = {}
+    row.columnFilters = makeObjectMap()
+    row.columnFiltersMeta = makeObjectMap()
 
     if (resolvedColumnFilters.length) {
       for (let j = 0; j < resolvedColumnFilters.length; j++) {
@@ -130,9 +129,10 @@ function _createFilteredRowModel<
           id,
           currentColumnFilter.resolvedValue,
           (filterMeta) => {
-            !row.columnFiltersMeta
-              ? (row.columnFiltersMeta = {})
-              : (row.columnFiltersMeta[id] = filterMeta)
+            if (!row.columnFiltersMeta) {
+              row.columnFiltersMeta = makeObjectMap()
+            }
+            row.columnFiltersMeta[id] = filterMeta
           },
         )
       }
@@ -149,9 +149,10 @@ function _createFilteredRowModel<
             id,
             currentGlobalFilter.resolvedValue,
             (filterMeta) => {
-              !row.columnFiltersMeta
-                ? (row.columnFiltersMeta = {})
-                : (row.columnFiltersMeta[id] = filterMeta)
+              if (!row.columnFiltersMeta) {
+                row.columnFiltersMeta = makeObjectMap()
+              }
+              row.columnFiltersMeta[id] = filterMeta
             },
           )
         ) {

package/src/features/column-filtering/filterRowsUtils.ts

@@ -1,4 +1,5 @@
 import { constructRow } from '../../core/rows/constructRow'
+import { makeObjectMap } from '../../utils'
 import type { Row_ColumnFiltering } from './columnFilteringFeature.types'
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
 import type { Row } from '../../types/Row'
@@ -37,7 +38,7 @@ function filterRowModelFromLeafs<
   table: Table_Internal<TFeatures, TData>,
 ): RowModel<TFeatures, TData> {
   const newFilteredFlatRows: Array<Row<TFeatures, TData>> = []
-  const newFilteredRowsById: Record<string, Row<TFeatures, TData>> = {}
+  const newFilteredRowsById = makeObjectMap<Row<TFeatures, TData>>()
   const maxDepth = table.options.maxLeafRowFilterDepth ?? 100
 
   const recurseFilterRows = (
@@ -109,7 +110,7 @@ function filterRowModelFromRoot<
   table: Table_Internal<TFeatures, TData>,
 ): RowModel<TFeatures, TData> {
   const newFilteredFlatRows: Array<Row<TFeatures, TData>> = []
-  const newFilteredRowsById: Record<string, Row<TFeatures, TData>> = {}
+  const newFilteredRowsById = makeObjectMap<Row<TFeatures, TData>>()
   const maxDepth = table.options.maxLeafRowFilterDepth ?? 100
 
   // Filters top level and nested rows

package/src/features/column-grouping/columnGroupingFeature.ts

@@ -1,6 +1,7 @@
 import {
   assignPrototypeAPIs,
   assignTableAPIs,
+  makeObjectMap,
   makeStateUpdater,
 } from '../../utils'
 import {
@@ -20,140 +21,96 @@ import {
   table_resetGrouping,
   table_setGrouping,
 } from './columnGroupingFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type {
-//   CachedRowModel_Grouped,
-//   Cell_ColumnGrouping,
-//   ColumnDef_ColumnGrouping,
-//   Column_ColumnGrouping,
-//   CreateRowModel_Grouped,
-//   RowModelFns_ColumnGrouping,
-//   Row_ColumnGrouping,
-//   TableOptions_ColumnGrouping,
-//   TableState_ColumnGrouping,
-//   Table_ColumnGrouping,
-// } from './columnGroupingFeature.types'
-
-export interface ColumnGroupingFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // CachedRowModel: CachedRowModel_Grouped<TFeatures, TData>
-  // Cell: Cell_ColumnGrouping
-  // Column: Column_ColumnGrouping<TFeatures, TData>
-  // ColumnDef: ColumnDef_ColumnGrouping<TFeatures, TData>
-  // CreateRowModels: CreateRowModel_Grouped<TFeatures, TData>
-  // Row: Row_ColumnGrouping
-  // RowModelFns: RowModelFns_ColumnGrouping<TFeatures, TData>
-  // Table: Table_ColumnGrouping<TFeatures, TData>
-  // TableOptions: TableOptions_ColumnGrouping
-  // TableState: TableState_ColumnGrouping
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock column grouping 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 column grouping state, aggregation defaults, and grouped row APIs.
  */
-export function constructColumnGroupingFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<ColumnGroupingFeatureConstructors<TFeatures, TData>> {
-  return {
-    getInitialState: (initialState) => {
-      return {
-        grouping: getDefaultGroupingState(),
-        ...initialState,
-      }
-    },
+export const columnGroupingFeature: TableFeature = {
+  getInitialState: (initialState) => {
+    return {
+      grouping: getDefaultGroupingState(),
+      ...initialState,
+    }
+  },
 
-    getDefaultColumnDef: () => {
-      return {
-        aggregatedCell: ({ getValue }: any) => getValue()?.toString?.() ?? null,
-        aggregationFn: 'auto',
-      }
-    },
+  getDefaultColumnDef: () => {
+    return {
+      aggregatedCell: ({ getValue }: any) => getValue()?.toString?.() ?? null,
+      aggregationFn: 'auto',
+    }
+  },
 
-    getDefaultTableOptions: (table) => {
-      return {
-        onGroupingChange: makeStateUpdater('grouping', table),
-        groupedColumnMode: 'reorder',
-      }
-    },
+  getDefaultTableOptions: (table) => {
+    return {
+      onGroupingChange: makeStateUpdater('grouping', table),
+      groupedColumnMode: 'reorder',
+    }
+  },
 
-    assignCellPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
-        cell_getIsGrouped: {
-          fn: (cell) => cell_getIsGrouped(cell),
-        },
-        cell_getIsPlaceholder: {
-          fn: (cell) => cell_getIsPlaceholder(cell),
-        },
-        cell_getIsAggregated: {
-          fn: (cell) => cell_getIsAggregated(cell),
-        },
-      })
-    },
+  assignCellPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
+      cell_getIsGrouped: {
+        fn: (cell) => cell_getIsGrouped(cell),
+      },
+      cell_getIsPlaceholder: {
+        fn: (cell) => cell_getIsPlaceholder(cell),
+      },
+      cell_getIsAggregated: {
+        fn: (cell) => cell_getIsAggregated(cell),
+      },
+    })
+  },
 
-    assignColumnPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
-        column_toggleGrouping: {
-          fn: (column) => column_toggleGrouping(column),
-        },
-        column_getCanGroup: {
-          fn: (column) => column_getCanGroup(column),
-        },
-        column_getIsGrouped: {
-          fn: (column) => column_getIsGrouped(column),
-        },
-        column_getGroupedIndex: {
-          fn: (column) => column_getGroupedIndex(column),
-        },
-        column_getToggleGroupingHandler: {
-          fn: (column) => column_getToggleGroupingHandler(column),
-        },
-        column_getAutoAggregationFn: {
-          fn: (column) => column_getAutoAggregationFn(column),
-        },
-        column_getAggregationFn: {
-          fn: (column) => column_getAggregationFn(column),
-        },
-      })
-    },
+  assignColumnPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
+      column_toggleGrouping: {
+        fn: (column) => column_toggleGrouping(column),
+      },
+      column_getCanGroup: {
+        fn: (column) => column_getCanGroup(column),
+      },
+      column_getIsGrouped: {
+        fn: (column) => column_getIsGrouped(column),
+      },
+      column_getGroupedIndex: {
+        fn: (column) => column_getGroupedIndex(column),
+      },
+      column_getToggleGroupingHandler: {
+        fn: (column) => column_getToggleGroupingHandler(column),
+      },
+      column_getAutoAggregationFn: {
+        fn: (column) => column_getAutoAggregationFn(column),
+      },
+      column_getAggregationFn: {
+        fn: (column) => column_getAggregationFn(column),
+      },
+    })
+  },
 
-    assignRowPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
-        row_getIsGrouped: {
-          fn: (row) => row_getIsGrouped(row),
-        },
-        row_getGroupingValue: {
-          fn: (row, columnId) => row_getGroupingValue(row, columnId),
-        },
-      })
-    },
+  assignRowPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
+      row_getIsGrouped: {
+        fn: (row) => row_getIsGrouped(row),
+      },
+      row_getGroupingValue: {
+        fn: (row, columnId) => row_getGroupingValue(row, columnId),
+      },
+    })
+  },
 
-    initRowInstanceData: (row) => {
-      ;(row as any)._groupingValuesCache = {}
-    },
+  initRowInstanceData: (row) => {
+    ;(row as any)._groupingValuesCache = makeObjectMap()
+  },
 
-    constructTableAPIs: (table) => {
-      assignTableAPIs('columnGroupingFeature', table, {
-        table_setGrouping: {
-          fn: (updater) => table_setGrouping(table, updater),
-        },
-        table_resetGrouping: {
-          fn: (defaultState) => table_resetGrouping(table, defaultState),
-        },
-      })
-    },
-  }
+  constructTableAPIs: (table) => {
+    assignTableAPIs('columnGroupingFeature', table, {
+      table_setGrouping: {
+        fn: (updater) => table_setGrouping(table, updater),
+      },
+      table_resetGrouping: {
+        fn: (defaultState) => table_resetGrouping(table, defaultState),
+      },
+    })
+  },
 }
-
-/**
- * The stock column grouping feature.
- *
- * Register this feature to add grouping state, aggregation defaults, grouped
- * row-model support, and table/row/column/cell grouping APIs.
- */
-export const columnGroupingFeature = constructColumnGroupingFeature()

package/src/features/column-grouping/columnGroupingFeature.types.ts

@@ -1,5 +1,4 @@
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
-import type { Table } from '../../types/Table'
 import type { BuiltInAggregationFn } from '../../fns/aggregationFns'
 import type {
   CellData,
@@ -7,7 +6,7 @@ import type {
   RowData,
   Updater,
 } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
+import type { IsAny, TableFeatures } from '../../types/TableFeatures'
 import type { Row } from '../../types/Row'
 import type { Cell } from '../../types/Cell'
 import type { ColumnDefTemplate } from '../../types/ColumnDef'
@@ -19,10 +18,10 @@ export interface TableState_ColumnGrouping {
 }
 
 export interface RowModelFns_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
-  aggregationFns: Record<keyof AggregationFns, AggregationFn<TFeatures, TData>>
+  aggregationFns: Record<string, AggregationFn<TFeatures, TData>>
 }
 
 export interface AggregationFns {}
@@ -41,18 +40,34 @@ export type CustomAggregationFns<
   TData extends RowData,
 > = Record<string, AggregationFn<TFeatures, TData>>
 
+/**
+ * Resolves the valid string names for `columnDef.aggregationFn` for a feature
+ * set.
+ *
+ * When the features object declares an `aggregationFns` registry
+ * (`tableFeatures({ ..., aggregationFns })`), its keys are the only valid
+ * names; a name is only assignable if an aggregation function is actually
+ * registered for it. Otherwise this falls back to the global
+ * declaration-merged `AggregationFns` interface.
+ */
+export type ExtractAggregationFnKeys<TFeatures extends TableFeatures> =
+  IsAny<TFeatures> extends true
+    ? keyof AggregationFns | BuiltInAggregationFn
+    : TFeatures extends { aggregationFns: infer TAggregationFns extends object }
+      ? Extract<keyof TAggregationFns, string>
+      : keyof AggregationFns
+
 export type AggregationFnOption<
   TFeatures extends TableFeatures,
   TData extends RowData,
 > =
   | 'auto'
-  | keyof AggregationFns
-  | BuiltInAggregationFn
+  | ExtractAggregationFnKeys<TFeatures>
   | AggregationFn<TFeatures, TData>
 
 export interface ColumnDef_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
   TValue extends CellData = CellData,
 > {
   /**
@@ -78,8 +93,8 @@ export interface ColumnDef_ColumnGrouping<
 }
 
 export interface Column_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Returns the aggregation function for the column.
@@ -175,8 +190,8 @@ export interface TableOptions_ColumnGrouping {
 export type GroupingColumnMode = false | 'reorder' | 'remove'
 
 export interface Table_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Resets `grouping` to `initialState.grouping`.
@@ -191,8 +206,8 @@ export interface Table_ColumnGrouping<
 }
 
 export interface Table_RowModels_Grouped<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Resolves the row model after grouping and aggregation have been applied.
@@ -204,23 +219,9 @@ export interface Table_RowModels_Grouped<
   getPreGroupedRowModel: () => RowModel<TFeatures, TData>
 }
 
-export interface CreateRowModel_Grouped<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * Factory used to retrieve the grouped row model. If using server-side
-   * grouping, this is not required. To use client-side grouping, pass
-   * `createGroupedRowModel()` or implement your own factory.
-   */
-  groupedRowModel?: (
-    table: Table<TFeatures, TData>,
-  ) => () => RowModel<TFeatures, TData>
-}
-
 export interface CachedRowModel_Grouped<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   groupedRowModel: () => RowModel<TFeatures, TData>
 }

package/src/features/column-grouping/columnGroupingFeature.utils.ts

@@ -1,4 +1,4 @@
-import { cloneState, isFunction } from '../../utils'
+import { cloneState, hasOwn, isFunction } from '../../utils'
 import type { Column_Internal } from '../../types/Column'
 import type { CellData, RowData, Updater } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
@@ -268,7 +268,7 @@ export function row_getGroupingValue<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(row: Row<TFeatures, TData> & Partial<Row_ColumnGrouping>, columnId: string) {
-  if (row._groupingValuesCache?.hasOwnProperty(columnId)) {
+  if (row._groupingValuesCache && hasOwn(row._groupingValuesCache, columnId)) {
     return row._groupingValuesCache[columnId]
   }