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

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])
     }
   })
 }
@@ -68,7 +68,9 @@ export function table_reset<
  * Merges new table options with the current resolved options.
  *
  * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise
- * options are shallow-merged.
+ * options are shallow-merged. Static options that should never change after
+ * initialization are restored on a fresh object so framework merge helpers may
+ * return readonly getter/proxy objects.
  *
  * @example
  * ```ts
@@ -82,14 +84,52 @@ export function table_mergeOptions<
   table: Table_Internal<TFeatures, TData>,
   newOptions: TableOptions<TFeatures, TData>,
 ) {
-  if (table.options.mergeOptions) {
-    return table.options.mergeOptions(table.options, newOptions)
+  const { features, atoms, initialState } = table.options
+
+  // simple merge if no mergeOptions is provided - performant
+  if (!table.options.mergeOptions) {
+    return {
+      ...table.options,
+      ...newOptions,
+      features,
+      atoms,
+      initialState,
+    }
   }
 
-  return {
-    ...table.options,
-    ...newOptions,
+  // else use the mergeOptions function and preserve getters/setters
+  const mergedOptions = table.options.mergeOptions(
+    table.options as TableOptions<TFeatures, TData>,
+    newOptions,
+  )
+  const descriptors: PropertyDescriptorMap = {
+    ...Object.getOwnPropertyDescriptors(mergedOptions),
   }
+
+  return Object.defineProperties(
+    Object.create(Object.getPrototypeOf(mergedOptions)),
+    {
+      ...descriptors,
+      features: {
+        value: features,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+      },
+      atoms: {
+        value: atoms,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+      },
+      initialState: {
+        value: initialState,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+      },
+    },
+  ) as TableOptions<TFeatures, TData>
 }
 
 /**
@@ -110,17 +150,11 @@ export function table_setOptions<
   table: Table_Internal<TFeatures, TData>,
   updater: Updater<TableOptions<TFeatures, TData>>,
 ): void {
-  const newOptions = functionalUpdate(updater, table.options)
-  // table static options that should never change after initialization
-  const { rowModels, features, atoms, initialState } = table.options
-  const mergedOptions = Object.assign(table_mergeOptions(table, newOptions), {
-    // Once the table instance is created those properties should never change after initialization,
-    // so we assign them back preserving the `table_mergeOptions` object reference
-    rowModels,
-    features,
-    atoms,
-    initialState,
-  })
+  const newOptions = functionalUpdate(
+    updater,
+    table.options as TableOptions<TFeatures, TData>,
+  )
+  const mergedOptions = table_mergeOptions(table, newOptions)
 
   if (table.optionsStore) {
     table.optionsStore.set(() => mergedOptions)

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/columnFacetingFeature.types.ts

@@ -4,8 +4,8 @@ import type { TableFeatures } from '../../types/TableFeatures'
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
 
 export interface Column_ColumnFaceting<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Computes min/max numeric facet values for this column.
@@ -25,65 +25,32 @@ export interface Column_ColumnFaceting<
 }
 
 export interface Table_RowModels_Faceted<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Computes min/max numeric facet values for the active faceting context.
    *
-   * Requires a `facetedMinMaxValues` row-model factory in `rowModels`.
+   * Requires a `facetedMinMaxValues` row-model factory on the `features` option.
    */
   getFacetedMinMaxValues: () => undefined | [number, number]
   /**
    * Computes the row model used to derive facet values.
    *
-   * Requires a `facetedRowModel` row-model factory in `rowModels`.
+   * Requires a `facetedRowModel` row-model factory on the `features` option.
    */
   getFacetedRowModel: () => RowModel<TFeatures, TData>
   /**
    * Computes unique facet values and occurrence counts.
    *
-   * Requires a `facetedUniqueValues` row-model factory in `rowModels`.
+   * Requires a `facetedUniqueValues` row-model factory on the `features` option.
    */
   getFacetedUniqueValues: () => Map<any, number>
 }
 
-export interface CreateRowModel_Faceted<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * Factory used to retrieve faceted min/max values. If using server-side
-   * faceting, this is not required. To use client-side faceting, pass
-   * `createFacetedMinMaxValues()` or implement your own factory.
-   */
-  facetedMinMaxValues?: (
-    table: Table<TFeatures, TData>,
-    columnId: string,
-  ) => () => [number, number] | undefined
-  /**
-   * Factory used to retrieve the faceted row model. If using server-side
-   * faceting, this is not required. To use client-side faceting, pass
-   * `createFacetedRowModel()` or implement your own factory.
-   */
-  facetedRowModel?: (
-    table: Table<TFeatures, TData>,
-    columnId: string,
-  ) => () => RowModel<TFeatures, TData>
-  /**
-   * Factory used to retrieve faceted unique values. If using server-side
-   * faceting, this is not required. To use client-side faceting, pass
-   * `createFacetedUniqueValues()` or implement your own factory.
-   */
-  facetedUniqueValues?: (
-    table: Table<TFeatures, TData>,
-    columnId: string,
-  ) => () => Map<any, number>
-}
-
 export interface CachedRowModel_Faceted<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   facetedRowModel?: (columnId: string) => () => RowModel<TFeatures, TData>
   facetedMinMaxValues?: (columnId: string) => [number, number]
@@ -91,8 +58,8 @@ export interface CachedRowModel_Faceted<
 }
 
 export interface Table_ColumnFaceting<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Returns the min and max values for the global filter.

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

@@ -24,7 +24,7 @@ export function column_getFacetedMinMaxValues<
   table: Table_Internal<TFeatures, TData>,
 ): [number, number] | undefined {
   const facetedMinMaxValuesFn =
-    table.options.rowModels?.facetedMinMaxValues?.(table, column.id) ??
+    table.options.features.facetedMinMaxValues?.(table, column.id) ??
     (() => undefined)
   return facetedMinMaxValuesFn()
 }
@@ -50,7 +50,7 @@ export function column_getFacetedRowModel<
   table: Table_Internal<TFeatures, TData>,
 ): RowModel<TFeatures, TData> {
   const facetedRowModelFn =
-    table.options.rowModels?.facetedRowModel?.(table, column?.id ?? '') ??
+    table.options.features.facetedRowModel?.(table, column?.id ?? '') ??
     (() => table.getPreFilteredRowModel())
   return facetedRowModelFn()
 }
@@ -75,7 +75,7 @@ export function column_getFacetedUniqueValues<
   table: Table_Internal<TFeatures, TData>,
 ): Map<any, number> {
   const facetedUniqueValuesFn =
-    table.options.rowModels?.facetedUniqueValues?.(table, column.id) ??
+    table.options.features.facetedUniqueValues?.(table, column.id) ??
     (() => new Map<any, number>())
   return facetedUniqueValuesFn()
 }
@@ -96,7 +96,7 @@ export function table_getGlobalFacetedMinMaxValues<
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): undefined | [number, number] {
   const facetedMinMaxValuesFn =
-    table.options.rowModels?.facetedMinMaxValues?.(table, '__global__') ??
+    table.options.features.facetedMinMaxValues?.(table, '__global__') ??
     (() => undefined)
   return facetedMinMaxValuesFn()
 }
@@ -118,7 +118,7 @@ export function table_getGlobalFacetedRowModel<
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
   const facetedRowModelFn =
-    table.options.rowModels?.facetedRowModel?.(table, '__global__') ??
+    table.options.features.facetedRowModel?.(table, '__global__') ??
     (() => table.getPreFilteredRowModel())
   return facetedRowModelFn()
 }
@@ -139,7 +139,7 @@ export function table_getGlobalFacetedUniqueValues<
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): Map<any, number> {
   const facetedUniqueValuesFn =
-    table.options.rowModels?.facetedUniqueValues?.(table, '__global__') ??
+    table.options.features.facetedUniqueValues?.(table, '__global__') ??
     (() => new Map())
   return facetedUniqueValuesFn()
 }

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

@@ -1,6 +1,7 @@
 import {
   assignPrototypeAPIs,
   assignTableAPIs,
+  makeObjectMap,
   makeStateUpdater,
 } from '../../utils'
 import {
@@ -15,115 +16,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 = makeObjectMap()
+    ;(row as any).columnFiltersMeta = makeObjectMap()
+  },
 
-    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()