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

package/src/types/TableOptions.ts

@@ -19,22 +19,17 @@ import type { TableOptions_RowSorting } from '../features/row-sorting/rowSorting
 import type { RowData, UnionToIntersection } from './type-utils'
 import type {
   ExtractFeatureMapTypes,
-  ExtractFeatureTypes,
+  NonFeatureKeys,
   TableFeatures,
 } from './TableFeatures'
 
-export interface TableOptions_Plugins<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {}
-
 /**
  * Core options that are always available on a table, before optional feature
  * options are mixed in.
  */
 export interface TableOptions_Core<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 >
   extends
     TableOptions_Table<TFeatures, TData>,
@@ -43,7 +38,10 @@ export interface TableOptions_Core<
     TableOptions_Rows<TFeatures, TData> {}
 
 type DebugKeysFor<TFeatures extends TableFeatures> = {
-  [K in keyof TFeatures & string as `debug${Capitalize<K>}`]?: boolean
+  [K in Exclude<
+    keyof TFeatures & string,
+    NonFeatureKeys // meta, row model, and fn registry slots, not real features
+  > as `debug${Capitalize<K>}`]?: boolean
 }
 
 export type DebugOptions<TFeatures extends TableFeatures> = {
@@ -57,8 +55,8 @@ export type DebugOptions<TFeatures extends TableFeatures> = {
 } & DebugKeysFor<CoreFeatures & TFeatures>
 
 export interface TableOptions_FeatureMap<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   columnFilteringFeature: TableOptions_ColumnFiltering<TFeatures, TData>
   columnGroupingFeature: TableOptions_ColumnGrouping
@@ -75,15 +73,42 @@ export interface TableOptions_FeatureMap<
   rowSortingFeature: TableOptions_RowSorting
 }
 
-export type TableOptions_FeatureMap_All<
+type TableOptions_StockFeatureKeys =
+  | 'columnFilteringFeature'
+  | 'columnGroupingFeature'
+  | 'columnOrderingFeature'
+  | 'columnPinningFeature'
+  | 'columnResizingFeature'
+  | 'columnSizingFeature'
+  | 'columnVisibilityFeature'
+  | 'globalFilteringFeature'
+  | 'rowExpandingFeature'
+  | 'rowPaginationFeature'
+  | 'rowPinningFeature'
+  | 'rowSelectionFeature'
+  | 'rowSortingFeature'
+
+/**
+ * Plugin entries declaration-merged into `TableOptions_FeatureMap`, i.e. keys
+ * beyond the stock set. Resolves to `unknown` (an intersection no-op) when no
+ * plugins are merged so the common case skips the union-to-intersection work.
+ */
+type TableOptions_PluginFeatureMapTypes<
   TFeatures extends TableFeatures,
   TData extends RowData,
-> = UnionToIntersection<
-  TableOptions_FeatureMap<TFeatures, TData>[keyof TableOptions_FeatureMap<
-    TFeatures,
-    TData
-  >]
->
+> = [
+  Exclude<
+    keyof TableOptions_FeatureMap<TFeatures, TData>,
+    TableOptions_StockFeatureKeys
+  >,
+] extends [never]
+  ? unknown
+  : UnionToIntersection<
+      TableOptions_FeatureMap<TFeatures, TData>[Exclude<
+        keyof TableOptions_FeatureMap<TFeatures, TData>,
+        TableOptions_StockFeatureKeys
+      >]
+    >
 
 /**
  * Complete table options for a specific feature set.
@@ -97,8 +122,6 @@ export type TableOptions<
   TData extends RowData,
 > = TableOptions_Core<TFeatures, TData> &
   ExtractFeatureMapTypes<TFeatures, TableOptions_FeatureMap<TFeatures, TData>> &
-  ExtractFeatureTypes<'TableOptions', TFeatures> &
-  TableOptions_Plugins<TFeatures, TData> &
   DebugOptions<TFeatures>
 
 /**
@@ -109,4 +132,19 @@ export type TableOptions_All<
   TFeatures extends TableFeatures,
   TData extends RowData,
 > = TableOptions_Core<TFeatures, TData> &
-  Partial<TableOptions_FeatureMap_All<TFeatures, TData>>
+  Partial<
+    TableOptions_ColumnFiltering<TFeatures, TData> &
+      TableOptions_ColumnGrouping &
+      TableOptions_ColumnOrdering &
+      TableOptions_ColumnPinning &
+      TableOptions_ColumnResizing &
+      TableOptions_ColumnSizing &
+      TableOptions_ColumnVisibility &
+      TableOptions_GlobalFiltering<TFeatures, TData> &
+      TableOptions_RowExpanding<TFeatures, TData> &
+      TableOptions_RowPagination &
+      TableOptions_RowPinning<TFeatures, TData> &
+      TableOptions_RowSelection<TFeatures, TData> &
+      TableOptions_RowSorting &
+      TableOptions_PluginFeatureMapTypes<TFeatures, TData>
+  >

package/src/types/TableState.ts

@@ -11,17 +11,7 @@ import type { TableState_RowPagination } from '../features/row-pagination/rowPag
 import type { TableState_RowPinning } from '../features/row-pinning/rowPinningFeature.types'
 import type { TableState_RowSelection } from '../features/row-selection/rowSelectionFeature.types'
 import type { TableState_RowSorting } from '../features/row-sorting/rowSortingFeature.types'
-import type {
-  ExtractFeatureMapTypes,
-  ExtractFeatureTypes,
-  TableFeatures,
-} from './TableFeatures'
-
-/**
- * Use this interface as a target for declaration merging to add your own state properties.
- * Note: This will affect the types of all tables in your project.
- */
-export interface TableState_Plugins<TFeatures extends TableFeatures> {}
+import type { ExtractFeatureMapTypes, TableFeatures } from './TableFeatures'
 
 export interface TableState_FeatureMap {
   columnFilteringFeature: TableState_ColumnFiltering
@@ -46,17 +36,15 @@ export interface TableState_FeatureMap {
  * then custom feature/plugin state is mixed in.
  */
 export type TableState<TFeatures extends TableFeatures> =
-  ExtractFeatureMapTypes<TFeatures, TableState_FeatureMap> &
-    ExtractFeatureTypes<'TableState', TFeatures> &
-    TableState_Plugins<TFeatures>
+  ExtractFeatureMapTypes<TFeatures, TableState_FeatureMap>
 
 /**
- * Internal broad state shape containing every stock feature state slice.
+ * Internal broad state shape containing every registered feature state slice.
  *
  * Feature internals use this when they may need to inspect optional slices owned
  * by other features.
  */
-export type TableState_All = Partial<
+export interface TableState_All extends Partial<
   TableState_ColumnFiltering &
     TableState_ColumnGrouping &
     TableState_ColumnOrdering &
@@ -70,4 +58,4 @@ export type TableState_All = Partial<
     TableState_RowPinning &
     TableState_RowSelection &
     TableState_RowSorting
->
+> {}

package/src/utils.ts

@@ -1,4 +1,4 @@
-import type { Table, Table_Internal } from './types/Table'
+import type { Table_Internal } from './types/Table'
 import type { NoInfer, RowData, Updater } from './types/type-utils'
 import type { TableFeatures } from './types/TableFeatures'
 import type { TableState, TableState_All } from './types/TableState'
@@ -31,12 +31,17 @@ export function cloneState<T>(value: T): T {
       return value
     }
 
-    const copy: Record<string, unknown> = {}
+    const copy: Record<string, unknown> = proto === null ? makeObjectMap() : {}
     const keys = Object.keys(value)
 
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i]!
-      copy[key] = cloneState((value as Record<string, unknown>)[key])
+      Object.defineProperty(copy, key, {
+        configurable: true,
+        enumerable: true,
+        value: cloneState((value as Record<string, unknown>)[key]),
+        writable: true,
+      })
     }
 
     return copy as T
@@ -45,6 +50,23 @@ export function cloneState<T>(value: T): T {
   return value
 }
 
+/**
+ * Creates an object intended only for string-keyed dictionary lookups.
+ *
+ * The null prototype keeps user-controlled ids such as `__proto__` and
+ * `hasOwnProperty` as plain data keys.
+ */
+export function makeObjectMap<TValue = unknown>(): Record<string, TValue> {
+  return Object.create(null) as Record<string, TValue>
+}
+
+/**
+ * Checks whether an object owns a key, including null-prototype dictionaries.
+ */
+export function hasOwn(obj: object, key: PropertyKey): boolean {
+  return Object.prototype.hasOwnProperty.call(obj, key)
+}
+
 /**
  * Creates a table state updater for a single state slice.
  *
@@ -53,7 +75,16 @@ export function cloneState<T>(value: T): T {
 export function makeStateUpdater<
   TFeatures extends TableFeatures,
   K extends (string & {}) | keyof TableState_All | keyof TableState<TFeatures>,
->(key: K, instance: Table<TFeatures, any>) {
+>(
+  key: K,
+  // Minimal structural shape so any table view (public `Table`,
+  // `Table_Internal`, or a custom plugin table) can be passed without forcing
+  // the compiler to relate the full table types.
+  instance: {
+    readonly options: { readonly atoms?: object | undefined }
+    readonly baseAtoms: object
+  },
+) {
   return (updater: Updater<TableState<any>[K & keyof TableState<any>]>) => {
     const externalAtom = (instance.options as any).atoms?.[key]
     const targetAtom = externalAtom ?? (instance.baseAtoms as any)[key]
@@ -427,13 +458,14 @@ export function assignPrototypeAPIs<
  */
 export function callMemoOrStaticFn<
   TObject extends Record<string, any>,
-  TStaticFn extends AnyFunction,
+  TArgs extends Array<any>,
+  TReturn,
 >(
   obj: TObject,
   fnKey: string,
-  staticFn: TStaticFn,
-  ...args: Parameters<TStaticFn> extends [any, ...infer Rest] ? Rest : never
-): ReturnType<TStaticFn> {
+  staticFn: (obj: TObject, ...args: TArgs) => TReturn,
+  ...args: TArgs
+): TReturn {
   return (
     (obj[fnKey] as Function | undefined)?.(...args) ?? staticFn(obj, ...args)
   )