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

package/src/core/table/constructTable.ts

@@ -7,7 +7,7 @@ import type { RowData } from '../../types/type-utils'
 import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
 import type { Table, Table_Internal } from '../../types/Table'
 import type { TableOptions } from '../../types/TableOptions'
-import type { TableState } from '../../types/TableState'
+import type { TableState, TableState_All } from '../../types/TableState'
 
 /**
  * Builds the initial table state from registered features and user initial state.
@@ -44,7 +44,7 @@ export function constructTable<
     atoms: {},
   } as Table_Internal<TFeatures, TData>
 
-  const featuresList: Array<TableFeature<{}>> = Object.values(table._features)
+  const featuresList: Array<TableFeature> = Object.values(table._features)
 
   const defaultOptions = featuresList.reduce((obj, feature) => {
     return Object.assign(obj, feature.getDefaultTableOptions?.(table))
@@ -100,7 +100,7 @@ export function constructTable<
   )
 
   const stateKeys = Object.keys(table.initialState) as Array<
-    string & keyof TableState<TFeatures>
+    string & keyof TableState_All
   >
 
   for (let i = 0; i < stateKeys.length; i++) {
@@ -115,11 +115,14 @@ export function constructTable<
     // create readonly derived atom: on each get(), read either external atom or base atom
     ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(
       () => {
-        const externalAtom = table.options.atoms?.[key]
+        const externalAtoms = table.options.atoms as
+          | Partial<Record<keyof TableState_All, Atom<unknown>>>
+          | undefined
+        const externalAtom = externalAtoms?.[key]
         if (externalAtom) {
           return externalAtom.get()
         }
-        return table.baseAtoms[key].get()
+        return table.baseAtoms[key]!.get()
       },
       { debugName: `table/atoms/${key}` },
     )
@@ -130,10 +133,10 @@ export function constructTable<
   table.store = atomToStore(
     _reactivity.createReadonlyAtom(
       () => {
-        const snapshot = {} as TableState<TFeatures>
+        const snapshot = {} as TableState<TFeatures> & TableState_All
         for (let i = 0; i < stateKeys.length; i++) {
           const key = stateKeys[i]!
-          ;(snapshot as Record<string, unknown>)[key] = table.atoms[key].get()
+          ;(snapshot as Record<string, unknown>)[key] = table.atoms[key]!.get()
         }
         return snapshot
       },

package/src/core/table/coreTablesFeature.ts

@@ -1,41 +1,19 @@
 import { assignTableAPIs } from '../../utils'
 import { table_reset, table_setOptions } from './coreTablesFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type { TableOptions_Table, Table_Table } from './coreTablesFeature.types'
-
-export interface CoreTablesFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // Table: Table_Table<TFeatures, TData>
-  // TableOptions: TableOptions_Table<TFeatures, TData>
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock core tables feature.
- *
- * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ * Core feature that adds base table instance APIs such as reset and setOptions.
  */
-export function constructCoreTablesFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<CoreTablesFeatureConstructors<TFeatures, TData>> {
-  return {
-    constructTableAPIs: (table) => {
-      assignTableAPIs('coreTablesFeature', table, {
-        table_reset: {
-          fn: () => table_reset(table),
-        },
-        table_setOptions: {
-          fn: (updater) => table_setOptions(table, updater),
-        },
-      })
-    },
-  }
+export const coreTablesFeature: TableFeature = {
+  constructTableAPIs: (table) => {
+    assignTableAPIs('coreTablesFeature', table, {
+      table_reset: {
+        fn: () => table_reset(table),
+      },
+      table_setOptions: {
+        fn: (updater) => table_setOptions(table, updater),
+      },
+    })
+  },
 }
-
-/**
- * The Core Tables feature provides the core table functionality for handling state and options.
- */
-export const coreTablesFeature = constructCoreTablesFeature()

package/src/core/table/coreTablesFeature.utils.ts

@@ -59,7 +59,7 @@ export function table_reset<
     const keys = Object.keys(snap) as Array<keyof typeof snap>
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i]!
-      ;(table.baseAtoms as any)[key].set(snap[key] as any)
+      ;(table.baseAtoms as any)[key].set(snap[key])
     }
   })
 }

package/src/features/column-faceting/columnFacetingFeature.ts

@@ -11,110 +11,79 @@ import {
   table_getGlobalFacetedRowModel,
   table_getGlobalFacetedUniqueValues,
 } from './columnFacetingFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-import type { Column_Internal } from '../../types/Column'
-// import type {
-//   CachedRowModel_Faceted,
-//   Column_ColumnFaceting,
-//   CreateRowModel_Faceted,
-// } from './columnFacetingFeature.types'
-
-export interface ColumnFacetingFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // CachedRowModel: CachedRowModel_Faceted<TFeatures, TData>
-  // Column: Column_ColumnFaceting<TFeatures, TData>
-  // CreateRowModels: CreateRowModel_Faceted<TFeatures, TData>
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock column faceting feature.
- *
- * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ * Feature that derives faceted row models, unique values, and min/max values for filters.
  */
-export function constructColumnFacetingFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<ColumnFacetingFeatureConstructors<TFeatures, TData>> {
-  return {
-    assignColumnPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnFacetingFeature', prototype, table, {
-        column_getFacetedRowModel: {
-          memoDeps: () => [
-            table.getPreFilteredRowModel().rows,
-            table.atoms.columnFilters?.get(),
-            table.atoms.globalFilter?.get(),
-            table.getFilteredRowModel().rows,
-          ],
-          fn: (column) => column_getFacetedRowModel(column, column.table),
-        },
-        column_getFacetedMinMaxValues: {
-          memoDeps: (column: Column_Internal<TFeatures, TData>) => [
-            callMemoOrStaticFn(
-              column,
-              'getFacetedRowModel',
-              column_getFacetedRowModel,
-              column.table,
-            ).flatRows,
-          ],
-          fn: (column) => column_getFacetedMinMaxValues(column, column.table),
-        },
-        column_getFacetedUniqueValues: {
-          memoDeps: (column: Column_Internal<TFeatures, TData>) => [
-            callMemoOrStaticFn(
-              column,
-              'getFacetedRowModel',
-              column_getFacetedRowModel,
-              column.table,
-            ).flatRows,
-          ],
-          fn: (column) => column_getFacetedUniqueValues(column, column.table),
-        },
-      })
-    },
+export const columnFacetingFeature: TableFeature = {
+  assignColumnPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnFacetingFeature', prototype, table, {
+      column_getFacetedRowModel: {
+        memoDeps: () => [
+          table.getPreFilteredRowModel().rows,
+          table.atoms.columnFilters?.get(),
+          table.atoms.globalFilter?.get(),
+          table.getFilteredRowModel().rows,
+        ],
+        fn: (column) => column_getFacetedRowModel(column, column.table),
+      },
+      column_getFacetedMinMaxValues: {
+        memoDeps: (column) => [
+          callMemoOrStaticFn(
+            column,
+            'getFacetedRowModel',
+            column_getFacetedRowModel,
+            column.table,
+          ).flatRows,
+        ],
+        fn: (column) => column_getFacetedMinMaxValues(column, column.table),
+      },
+      column_getFacetedUniqueValues: {
+        memoDeps: (column) => [
+          callMemoOrStaticFn(
+            column,
+            'getFacetedRowModel',
+            column_getFacetedRowModel,
+            column.table,
+          ).flatRows,
+        ],
+        fn: (column) => column_getFacetedUniqueValues(column, column.table),
+      },
+    })
+  },
 
-    constructTableAPIs: (table) => {
-      assignTableAPIs('columnFacetingFeature', table, {
-        table_getGlobalFacetedRowModel: {
-          memoDeps: () => [
-            table.getPreFilteredRowModel().rows,
-            table.atoms.columnFilters?.get(),
-            table.atoms.globalFilter?.get(),
-            table.getFilteredRowModel().rows,
-          ],
-          fn: () => table_getGlobalFacetedRowModel(table),
-        },
-        table_getGlobalFacetedMinMaxValues: {
-          memoDeps: () => [
-            callMemoOrStaticFn(
-              table,
-              'getGlobalFacetedRowModel',
-              table_getGlobalFacetedRowModel,
-            ).flatRows,
-          ],
-          fn: () => table_getGlobalFacetedMinMaxValues(table),
-        },
-        table_getGlobalFacetedUniqueValues: {
-          memoDeps: () => [
-            callMemoOrStaticFn(
-              table,
-              'getGlobalFacetedRowModel',
-              table_getGlobalFacetedRowModel,
-            ).flatRows,
-          ],
-          fn: () => table_getGlobalFacetedUniqueValues(table),
-        },
-      })
-    },
-  }
+  constructTableAPIs: (table) => {
+    assignTableAPIs('columnFacetingFeature', table, {
+      table_getGlobalFacetedRowModel: {
+        memoDeps: () => [
+          table.getPreFilteredRowModel().rows,
+          table.atoms.columnFilters?.get(),
+          table.atoms.globalFilter?.get(),
+          table.getFilteredRowModel().rows,
+        ],
+        fn: () => table_getGlobalFacetedRowModel(table),
+      },
+      table_getGlobalFacetedMinMaxValues: {
+        memoDeps: () => [
+          callMemoOrStaticFn(
+            table,
+            'getGlobalFacetedRowModel',
+            table_getGlobalFacetedRowModel,
+          ).flatRows,
+        ],
+        fn: () => table_getGlobalFacetedMinMaxValues(table),
+      },
+      table_getGlobalFacetedUniqueValues: {
+        memoDeps: () => [
+          callMemoOrStaticFn(
+            table,
+            'getGlobalFacetedRowModel',
+            table_getGlobalFacetedRowModel,
+          ).flatRows,
+        ],
+        fn: () => table_getGlobalFacetedUniqueValues(table),
+      },
+    })
+  },
 }
-
-/**
- * The stock column faceting feature.
- *
- * Register this feature to add faceted row model, unique value, and min/max
- * helpers for column and global filter UIs.
- */
-export const columnFacetingFeature = constructColumnFacetingFeature()

package/src/features/column-faceting/createFacetedMinMaxValues.ts

@@ -18,7 +18,7 @@ export function createFacetedMinMaxValues<
   columnId: string,
 ) => () => undefined | [number, number] {
   return (_table, columnId) => {
-    const table: Table_Internal<TFeatures, TData> = _table
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     return tableMemo({
       feature: 'columnFacetingFeature',
       fn: (flatRows) => _createFacetedMinMaxValues(columnId, flatRows),

package/src/features/column-faceting/createFacetedRowModel.ts

@@ -23,7 +23,7 @@ export function createFacetedRowModel<
   columnId: string,
 ) => () => RowModel<TFeatures, TData> {
   return (_table, columnId) => {
-    const table: Table_Internal<TFeatures, TData> = _table
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     return tableMemo({
       feature: 'columnFacetingFeature',
       table,

package/src/features/column-faceting/createFacetedUniqueValues.ts

@@ -18,7 +18,7 @@ export function createFacetedUniqueValues<
   columnId: string,
 ) => () => Map<any, number> {
   return (_table, columnId) => {
-    const table: Table_Internal<TFeatures, TData> = _table
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     return tableMemo({
       feature: 'columnFacetingFeature',
       table,

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

@@ -15,115 +15,72 @@ import {
   table_resetColumnFilters,
   table_setColumnFilters,
 } from './columnFilteringFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type {
-//   CachedRowModel_Filtered,
-//   ColumnDef_ColumnFiltering,
-//   Column_ColumnFiltering,
-//   CreateRowModel_Filtered,
-//   RowModelFns_ColumnFiltering,
-//   Row_ColumnFiltering,
-//   TableOptions_ColumnFiltering,
-//   TableState_ColumnFiltering,
-//   Table_ColumnFiltering,
-// } from './columnFilteringFeature.types'
-
-export interface ColumnFilteringFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // CachedRowModel: CachedRowModel_Filtered<TFeatures, TData>
-  // Column: Column_ColumnFiltering<TFeatures, TData>
-  // ColumnDef: ColumnDef_ColumnFiltering<TFeatures, TData>
-  // CreateRowModels: CreateRowModel_Filtered<TFeatures, TData>
-  // Row: Row_ColumnFiltering<TFeatures, TData>
-  // RowModelFns: RowModelFns_ColumnFiltering<TFeatures, TData>
-  // Table: Table_ColumnFiltering<TFeatures, TData>
-  // TableOptions: TableOptions_ColumnFiltering<TFeatures, TData>
-  // TableState: TableState_ColumnFiltering
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock column filtering 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 per-column filtering state, options, and column/table filter APIs.
  */
-export function constructColumnFilteringFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<ColumnFilteringFeatureConstructors<TFeatures, TData>> {
-  return {
-    getInitialState: (initialState) => {
-      return {
-        columnFilters: getDefaultColumnFiltersState(),
-        ...initialState,
-      }
-    },
+export const columnFilteringFeature: TableFeature = {
+  getInitialState: (initialState) => {
+    return {
+      columnFilters: getDefaultColumnFiltersState(),
+      ...initialState,
+    }
+  },
 
-    getDefaultColumnDef: () => {
-      return {
-        filterFn: 'auto',
-      }
-    },
+  getDefaultColumnDef: () => {
+    return {
+      filterFn: 'auto',
+    }
+  },
 
-    getDefaultTableOptions: (table) => {
-      return {
-        onColumnFiltersChange: makeStateUpdater('columnFilters', table),
-        filterFromLeafRows: false,
-        maxLeafRowFilterDepth: 100,
-      }
-    },
+  getDefaultTableOptions: (table) => {
+    return {
+      onColumnFiltersChange: makeStateUpdater('columnFilters', table),
+      filterFromLeafRows: false,
+      maxLeafRowFilterDepth: 100,
+    }
+  },
 
-    assignColumnPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnFilteringFeature', prototype, table, {
-        column_getAutoFilterFn: {
-          fn: (column) => column_getAutoFilterFn(column),
-        },
-        column_getFilterFn: {
-          fn: (column) => column_getFilterFn(column),
-        },
-        column_getCanFilter: {
-          fn: (column) => column_getCanFilter(column),
-        },
-        column_getIsFiltered: {
-          fn: (column) => column_getIsFiltered(column),
-        },
-        column_getFilterValue: {
-          fn: (column) => column_getFilterValue(column),
-        },
-        column_getFilterIndex: {
-          fn: (column) => column_getFilterIndex(column),
-        },
-        column_setFilterValue: {
-          fn: (column, value) => column_setFilterValue(column, value),
-        },
-      })
-    },
+  assignColumnPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnFilteringFeature', prototype, table, {
+      column_getAutoFilterFn: {
+        fn: (column) => column_getAutoFilterFn(column),
+      },
+      column_getFilterFn: {
+        fn: (column) => column_getFilterFn(column),
+      },
+      column_getCanFilter: {
+        fn: (column) => column_getCanFilter(column),
+      },
+      column_getIsFiltered: {
+        fn: (column) => column_getIsFiltered(column),
+      },
+      column_getFilterValue: {
+        fn: (column) => column_getFilterValue(column),
+      },
+      column_getFilterIndex: {
+        fn: (column) => column_getFilterIndex(column),
+      },
+      column_setFilterValue: {
+        fn: (column, value) => column_setFilterValue(column, value),
+      },
+    })
+  },
 
-    initRowInstanceData: (row) => {
-      ;(row as any).columnFilters = {}
-      ;(row as any).columnFiltersMeta = {}
-    },
+  initRowInstanceData: (row) => {
+    ;(row as any).columnFilters = {}
+    ;(row as any).columnFiltersMeta = {}
+  },
 
-    constructTableAPIs: (table) => {
-      assignTableAPIs('columnFilteringFeature', table, {
-        table_setColumnFilters: {
-          fn: (updater) => table_setColumnFilters(table, updater),
-        },
-        table_resetColumnFilters: {
-          fn: (defaultState) => table_resetColumnFilters(table, defaultState),
-        },
-      })
-    },
-  }
+  constructTableAPIs: (table) => {
+    assignTableAPIs('columnFilteringFeature', table, {
+      table_setColumnFilters: {
+        fn: (updater) => table_setColumnFilters(table, updater),
+      },
+      table_resetColumnFilters: {
+        fn: (defaultState) => table_resetColumnFilters(table, defaultState),
+      },
+    })
+  },
 }
-
-/**
- * The stock column filtering feature.
- *
- * Register this feature to add column filter state, filter defaults, and
- * table/row/column APIs for client-side or manual column filtering. Global
- * filtering is provided by `globalFilteringFeature`.
- */
-export const columnFilteringFeature = constructColumnFilteringFeature()

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

@@ -39,7 +39,7 @@ export interface RowModelFns_ColumnFiltering<
   TFeatures extends TableFeatures,
   TData extends RowData,
 > {
-  filterFns: Record<keyof FilterFns, FilterFn<TFeatures, TData>>
+  filterFns: Record<keyof FilterFns, FilterFn<TFeatures, RowData>>
 }
 
 export interface FilterFn<
@@ -71,12 +71,12 @@ export type ColumnFilterAutoRemoveTestFn<
 export type CustomFilterFns<
   TFeatures extends TableFeatures,
   TData extends RowData,
-> = Record<string, FilterFn<TFeatures, TData>>
+> = Record<string, FilterFn<TFeatures, RowData>>
 
 export type FilterFnOption<
   TFeatures extends TableFeatures,
   TData extends RowData,
-> = 'auto' | BuiltInFilterFn | keyof FilterFns | FilterFn<TFeatures, TData>
+> = 'auto' | BuiltInFilterFn | keyof FilterFns | FilterFn<TFeatures, RowData>
 
 export interface ColumnDef_ColumnFiltering<
   TFeatures extends TableFeatures,

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

@@ -40,7 +40,7 @@ export function column_getAutoFilterFn<
   TData extends RowData,
   TValue extends CellData = CellData,
 >(column: Column_Internal<TFeatures, TData, TValue>) {
-  const filterFns: Record<string, FilterFn<TFeatures, TData>> | undefined =
+  const filterFns: Record<string, FilterFn<TFeatures, RowData>> | undefined =
     column.table._rowModelFns.filterFns
 
   const firstRow = column.table.getCoreRowModel().flatRows[0]
@@ -90,7 +90,7 @@ export function column_getFilterFn<
   column: Column_Internal<TFeatures, TData, TValue>,
 ): FilterFn<TFeatures, TData> | undefined {
   let filterFn = null
-  const filterFns: Record<string, FilterFn<TFeatures, TData>> | undefined =
+  const filterFns: Record<string, FilterFn<TFeatures, RowData>> | undefined =
     column.table._rowModelFns.filterFns
   filterFn = isFunction(column.columnDef.filterFn)
     ? column.columnDef.filterFn
@@ -104,7 +104,7 @@ export function column_getFilterFn<
     )
   }
 
-  return filterFn
+  return filterFn as FilterFn<TFeatures, TData> | undefined
 }
 
 /**
@@ -323,7 +323,7 @@ export function shouldAutoRemoveFilter<
 ) {
   return (
     (filterFn && filterFn.autoRemove
-      ? filterFn.autoRemove(value, column)
+      ? filterFn.autoRemove(value, column as Column_Internal<TFeatures, TData>)
       : false) ||
     typeof value === 'undefined' ||
     (typeof value === 'string' && !value)

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

@@ -28,10 +28,10 @@ export function createFilteredRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData = any,
 >(
-  filterFns: Record<keyof FilterFns, FilterFn<TFeatures, TData>>,
+  filterFns: Record<keyof FilterFns, FilterFn<TFeatures, RowData>>,
 ): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {
   return (_table) => {
-    const table: Table_Internal<TFeatures, TData> = _table
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     if (!table._rowModelFns.filterFns) table._rowModelFns.filterFns = filterFns
     return tableMemo({
       feature: 'columnFilteringFeature',