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

package/src/features/column-visibility/columnVisibilityFeature.ts

@@ -20,140 +20,103 @@ import {
   table_setColumnVisibility,
   table_toggleAllColumnsVisible,
 } from './columnVisibilityFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type {
-//   ColumnDef_ColumnVisibility,
-//   Column_ColumnVisibility,
-//   Row_ColumnVisibility,
-//   TableOptions_ColumnVisibility,
-//   TableState_ColumnVisibility,
-//   Table_ColumnVisibility,
-// } from './columnVisibilityFeature.types'
-
-export interface ColumnVisibilityFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // ColumnDef: ColumnDef_ColumnVisibility
-  // Column: Column_ColumnVisibility
-  // Row: Row_ColumnVisibility<TFeatures, TData>
-  // Table: Table_ColumnVisibility<TFeatures, TData>
-  // TableOptions: TableOptions_ColumnVisibility
-  // TableState: TableState_ColumnVisibility
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock column visibility 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 visibility state and APIs for hiding and showing columns.
  */
-export function constructColumnVisibilityFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<ColumnVisibilityFeatureConstructors<TFeatures, TData>> {
-  return {
-    getInitialState: (initialState) => {
-      return {
-        columnVisibility: getDefaultColumnVisibilityState(),
-        ...initialState,
-      }
-    },
+export const columnVisibilityFeature: TableFeature = {
+  getInitialState: (initialState) => {
+    return {
+      columnVisibility: getDefaultColumnVisibilityState(),
+      ...initialState,
+    }
+  },
 
-    getDefaultTableOptions: (table) => {
-      return {
-        onColumnVisibilityChange: makeStateUpdater('columnVisibility', table),
-      }
-    },
+  getDefaultTableOptions: (table) => {
+    return {
+      onColumnVisibilityChange: makeStateUpdater('columnVisibility', table),
+    }
+  },
 
-    assignColumnPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {
-        column_getIsVisible: {
-          fn: (column) => column_getIsVisible(column),
-          memoDeps: (column) => [
-            table.options.columns,
-            table.atoms.columnVisibility?.get(),
-            column.columns,
-          ],
-        },
-        column_getCanHide: {
-          fn: (column) => column_getCanHide(column),
-        },
-        column_getToggleVisibilityHandler: {
-          fn: (column) => column_getToggleVisibilityHandler(column),
-        },
-        column_toggleVisibility: {
-          fn: (column, visible) => column_toggleVisibility(column, visible),
-        },
-      })
-    },
+  assignColumnPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {
+      column_getIsVisible: {
+        fn: (column) => column_getIsVisible(column),
+        memoDeps: (column) => [
+          table.options.columns,
+          table.atoms.columnVisibility?.get(),
+          column.columns,
+        ],
+      },
+      column_getCanHide: {
+        fn: (column) => column_getCanHide(column),
+      },
+      column_getToggleVisibilityHandler: {
+        fn: (column) => column_getToggleVisibilityHandler(column),
+      },
+      column_toggleVisibility: {
+        fn: (column, visible) => column_toggleVisibility(column, visible),
+      },
+    })
+  },
 
-    assignRowPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {
-        row_getVisibleCells: {
-          fn: (row) => row_getVisibleCells(row),
-          memoDeps: (row) => [
-            row.getAllCells(),
-            table.atoms.columnPinning?.get(),
-            table.atoms.columnVisibility?.get(),
-          ],
-        },
-        row_getVisibleCellsByColumnId: {
-          fn: (row) => row_getVisibleCellsByColumnId(row),
-          memoDeps: (row) => [
-            row.getAllCells(),
-            table.atoms.columnVisibility?.get(),
-          ],
-        },
-      })
-    },
+  assignRowPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnVisibilityFeature', prototype, table, {
+      row_getVisibleCells: {
+        fn: (row) => row_getVisibleCells(row),
+        memoDeps: (row) => [
+          row.getAllCells(),
+          table.atoms.columnPinning?.get(),
+          table.atoms.columnVisibility?.get(),
+        ],
+      },
+      row_getVisibleCellsByColumnId: {
+        fn: (row) => row_getVisibleCellsByColumnId(row),
+        memoDeps: (row) => [
+          row.getAllCells(),
+          table.atoms.columnVisibility?.get(),
+        ],
+      },
+    })
+  },
 
-    constructTableAPIs: (table) => {
-      assignTableAPIs('columnVisibilityFeature', table, {
-        table_getVisibleFlatColumns: {
-          fn: () => table_getVisibleFlatColumns(table),
-          memoDeps: () => [
-            table.atoms.columnVisibility?.get(),
-            table.atoms.columnOrder?.get(),
-            table.options.columns,
-          ],
-        },
-        table_getVisibleLeafColumns: {
-          fn: () => table_getVisibleLeafColumns(table),
-          memoDeps: () => [
-            table.atoms.columnVisibility?.get(),
-            table.atoms.columnOrder?.get(),
-            table.options.columns,
-          ],
-        },
-        table_setColumnVisibility: {
-          fn: (updater) => table_setColumnVisibility(table, updater),
-        },
-        table_resetColumnVisibility: {
-          fn: (defaultState) =>
-            table_resetColumnVisibility(table, defaultState),
-        },
-        table_toggleAllColumnsVisible: {
-          fn: (value) => table_toggleAllColumnsVisible(table, value),
-        },
-        table_getIsAllColumnsVisible: {
-          fn: () => table_getIsAllColumnsVisible(table),
-        },
-        table_getIsSomeColumnsVisible: {
-          fn: () => table_getIsSomeColumnsVisible(table),
-        },
-        table_getToggleAllColumnsVisibilityHandler: {
-          fn: () => table_getToggleAllColumnsVisibilityHandler(table),
-        },
-      })
-    },
-  }
+  constructTableAPIs: (table) => {
+    assignTableAPIs('columnVisibilityFeature', table, {
+      table_getVisibleFlatColumns: {
+        fn: () => table_getVisibleFlatColumns(table),
+        memoDeps: () => [
+          table.atoms.columnVisibility?.get(),
+          table.atoms.columnOrder?.get(),
+          table.options.columns,
+        ],
+      },
+      table_getVisibleLeafColumns: {
+        fn: () => table_getVisibleLeafColumns(table),
+        memoDeps: () => [
+          table.atoms.columnVisibility?.get(),
+          table.atoms.columnOrder?.get(),
+          table.options.columns,
+        ],
+      },
+      table_setColumnVisibility: {
+        fn: (updater) => table_setColumnVisibility(table, updater),
+      },
+      table_resetColumnVisibility: {
+        fn: (defaultState) => table_resetColumnVisibility(table, defaultState),
+      },
+      table_toggleAllColumnsVisible: {
+        fn: (value) => table_toggleAllColumnsVisible(table, value),
+      },
+      table_getIsAllColumnsVisible: {
+        fn: () => table_getIsAllColumnsVisible(table),
+      },
+      table_getIsSomeColumnsVisible: {
+        fn: () => table_getIsSomeColumnsVisible(table),
+      },
+      table_getToggleAllColumnsVisibilityHandler: {
+        fn: () => table_getToggleAllColumnsVisibilityHandler(table),
+      },
+    })
+  },
 }
-
-/**
- * The stock column visibility feature.
- *
- * Register this feature to add column visibility state and APIs for deriving
- * visible columns and visible row cells.
- */
-export const columnVisibilityFeature = constructColumnVisibilityFeature()

package/src/features/column-visibility/columnVisibilityFeature.types.ts

@@ -28,8 +28,8 @@ export type VisibilityDefaultOptions = Pick<
 >
 
 export interface Table_ColumnVisibility<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Checks whether every leaf column is currently visible.
@@ -76,8 +76,8 @@ export interface ColumnDef_ColumnVisibility {
 }
 
 export interface Row_ColumnVisibility<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Gets this row's cells for currently visible columns.

package/src/features/column-visibility/columnVisibilityFeature.utils.ts

@@ -1,4 +1,9 @@
-import { callMemoOrStaticFn, cloneState } from '../../utils'
+import {
+  callMemoOrStaticFn,
+  cloneState,
+  hasOwn,
+  makeObjectMap,
+} from '../../utils'
 import { getDefaultColumnPinningState } from '../column-pinning/columnPinningFeature.utils'
 import type { CellData, RowData, Updater } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
@@ -20,7 +25,7 @@ import type { Row } from '../../types/Row'
  * ```
  */
 export function getDefaultColumnVisibilityState(): ColumnVisibilityState {
-  return {}
+  return makeObjectMap()
 }
 
 /**
@@ -40,12 +45,13 @@ export function column_toggleVisibility<
   TValue extends CellData = CellData,
 >(column: Column_Internal<TFeatures, TData, TValue>, visible?: boolean): void {
   if (column_getCanHide(column)) {
-    table_setColumnVisibility(column.table, (old) => ({
-      ...old,
-      [column.id]:
+    table_setColumnVisibility(column.table, (old) => {
+      const next = Object.assign(makeObjectMap<boolean>(), old)
+      next[column.id] =
         visible ??
-        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),
-    }))
+        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)
+      return next
+    })
   }
 }
 
@@ -67,12 +73,17 @@ export function column_getIsVisible<
   TValue extends CellData = CellData,
 >(column: Column_Internal<TFeatures, TData, TValue>): boolean {
   const childColumns = column.columns
+  if (childColumns.length) {
+    return childColumns.some((childColumn) =>
+      callMemoOrStaticFn(childColumn, 'getIsVisible', column_getIsVisible),
+    )
+  }
+
+  const columnVisibility = column.table.atoms.columnVisibility?.get()
   return (
-    (childColumns.length
-      ? childColumns.some((childColumn) =>
-          callMemoOrStaticFn(childColumn, 'getIsVisible', column_getIsVisible),
-        )
-      : column.table.atoms.columnVisibility?.get()?.[column.id]) ?? true
+    (columnVisibility && hasOwn(columnVisibility, column.id)
+      ? columnVisibility[column.id]
+      : undefined) ?? true
   )
 }
 
@@ -192,7 +203,7 @@ export function row_getVisibleCellsByColumnId<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(row: Row<TFeatures, TData>): Record<string, Cell<TFeatures, TData, unknown>> {
-  const result: Record<string, Cell<TFeatures, TData, unknown>> = {}
+  const result = makeObjectMap<Cell<TFeatures, TData, unknown>>()
   const allCells = row.getAllCells()
   for (let i = 0; i < allCells.length; i++) {
     const cell = allCells[i]!
@@ -286,7 +297,12 @@ export function table_resetColumnVisibility<
 >(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {
   table_setColumnVisibility(
     table,
-    defaultState ? {} : cloneState(table.initialState.columnVisibility ?? {}),
+    defaultState
+      ? makeObjectMap()
+      : Object.assign(
+          makeObjectMap<boolean>(),
+          cloneState(table.initialState.columnVisibility ?? {}),
+        ),
   )
 }
 
@@ -306,7 +322,7 @@ export function table_toggleAllColumnsVisible<
 >(table: Table_Internal<TFeatures, TData>, value?: boolean) {
   value = value ?? !table_getIsAllColumnsVisible(table)
 
-  const visibility: Record<string, boolean> = {}
+  const visibility = makeObjectMap<boolean>()
   const leafColumns = table.getAllLeafColumns()
   for (let i = 0; i < leafColumns.length; i++) {
     const column = leafColumns[i]!

package/src/features/global-filtering/globalFilteringFeature.ts

@@ -10,90 +10,56 @@ import {
   table_resetGlobalFilter,
   table_setGlobalFilter,
 } from './globalFilteringFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type {
-//   ColumnDef_GlobalFiltering,
-//   Column_GlobalFiltering,
-//   TableOptions_GlobalFiltering,
-//   TableState_GlobalFiltering,
-//   Table_GlobalFiltering,
-// } from './globalFilteringFeature.types'
-
-export interface GlobalFilteringFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // Column: Column_GlobalFiltering
-  // ColumnDef: ColumnDef_GlobalFiltering
-  // Table: Table_GlobalFiltering<TFeatures, TData>
-  // TableOptions: TableOptions_GlobalFiltering<TFeatures, TData>
-  // TableState: TableState_GlobalFiltering
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock global 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 global filtering state, defaults, and global filter APIs.
  */
-export function constructGlobalFilteringFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<GlobalFilteringFeatureConstructors<TFeatures, TData>> {
-  return {
-    getInitialState: (initialState) => {
-      return {
-        globalFilter: undefined,
-        ...initialState,
-      }
-    },
+export const globalFilteringFeature: TableFeature = {
+  getInitialState: (initialState) => {
+    return {
+      globalFilter: undefined,
+      ...initialState,
+    }
+  },
 
-    getDefaultTableOptions: (table) => {
-      return {
-        onGlobalFilterChange: makeStateUpdater('globalFilter', table),
-        globalFilterFn: 'auto',
-        getColumnCanGlobalFilter: (column) => {
-          const value = table
-            .getCoreRowModel()
-            .flatRows[0]?.getAllCellsByColumnId()
-            [column.id]?.getValue()
+  getDefaultTableOptions: (table) => {
+    return {
+      onGlobalFilterChange: makeStateUpdater('globalFilter', table),
+      globalFilterFn: 'auto',
+      getColumnCanGlobalFilter: (column) => {
+        const value = table
+          .getCoreRowModel()
+          .flatRows[0]?.getAllCellsByColumnId()
+          [column.id]?.getValue()
 
-          return typeof value === 'string' || typeof value === 'number'
-        },
-      }
-    },
+        return typeof value === 'string' || typeof value === 'number'
+      },
+    }
+  },
 
-    assignColumnPrototype: (prototype, table) => {
-      assignPrototypeAPIs('globalFilteringFeature', prototype, table, {
-        column_getCanGlobalFilter: {
-          fn: (column) => column_getCanGlobalFilter(column),
-        },
-      })
-    },
+  assignColumnPrototype: (prototype, table) => {
+    assignPrototypeAPIs('globalFilteringFeature', prototype, table, {
+      column_getCanGlobalFilter: {
+        fn: (column) => column_getCanGlobalFilter(column),
+      },
+    })
+  },
 
-    constructTableAPIs: (table) => {
-      assignTableAPIs('globalFilteringFeature', table, {
-        table_getGlobalAutoFilterFn: {
-          fn: () => table_getGlobalAutoFilterFn(),
-        },
-        table_getGlobalFilterFn: {
-          fn: () => table_getGlobalFilterFn(table),
-        },
-        table_setGlobalFilter: {
-          fn: (updater) => table_setGlobalFilter(table, updater),
-        },
-        table_resetGlobalFilter: {
-          fn: (defaultState) => table_resetGlobalFilter(table, defaultState),
-        },
-      })
-    },
-  }
+  constructTableAPIs: (table) => {
+    assignTableAPIs('globalFilteringFeature', table, {
+      table_getGlobalAutoFilterFn: {
+        fn: () => table_getGlobalAutoFilterFn(),
+      },
+      table_getGlobalFilterFn: {
+        fn: () => table_getGlobalFilterFn(table),
+      },
+      table_setGlobalFilter: {
+        fn: (updater) => table_setGlobalFilter(table, updater),
+      },
+      table_resetGlobalFilter: {
+        fn: (defaultState) => table_resetGlobalFilter(table, defaultState),
+      },
+    })
+  },
 }
-
-/**
- * The stock global filtering feature.
- *
- * Register this feature with column filtering support to add global filter
- * state, global filter function resolution, and column eligibility APIs.
- */
-export const globalFilteringFeature = constructGlobalFilteringFeature()

package/src/features/global-filtering/globalFilteringFeature.types.ts

@@ -33,8 +33,8 @@ export interface Column_GlobalFiltering {
 }
 
 export interface TableOptions_GlobalFiltering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Enables global filtering across columns that allow it.
@@ -67,8 +67,8 @@ export interface TableOptions_GlobalFiltering<
 }
 
 export interface Table_GlobalFiltering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Currently, this function returns the built-in `includesString` filter function. In future releases, it may return more dynamic filter functions based on the nature of the data provided.

package/src/features/global-filtering/globalFilteringFeature.utils.ts

@@ -26,7 +26,7 @@ export function column_getCanGlobalFilter<
     (column.columnDef.enableGlobalFilter ?? true) &&
     (column.table.options.enableGlobalFilter ?? true) &&
     (column.table.options.enableFilters ?? true) &&
-    (column.table.options.getColumnCanGlobalFilter?.(column) ?? true) &&
+    (column.table.options.getColumnCanGlobalFilter?.(column as any) ?? true) &&
     !!column.accessorFn
   )
 }
@@ -63,16 +63,18 @@ export function table_getGlobalFilterFn<
   TData extends RowData,
 >(
   table: Table_Internal<TFeatures, TData>,
-): FilterFn<TFeatures, TData> | FilterFn<TFeatures, TData> | undefined {
+): FilterFn<TFeatures, TData> | undefined {
   const { globalFilterFn: globalFilterFn } = table.options
   const filterFns: Record<string, FilterFn<TFeatures, TData>> | undefined =
     table._rowModelFns.filterFns
 
-  return isFunction(globalFilterFn)
+  const filterFn = isFunction(globalFilterFn)
     ? globalFilterFn
     : globalFilterFn === 'auto'
       ? table_getGlobalAutoFilterFn()
       : filterFns?.[globalFilterFn as string]
+
+  return filterFn
 }
 
 /**

package/src/features/row-expanding/createExpandedRowModel.ts

@@ -16,7 +16,7 @@ export function createExpandedRowModel<
   TData extends RowData = any,
 >(): (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>
     return tableMemo({
       feature: 'rowExpandingFeature',
       table,