@tanstack/react-table 9.0.0-alpha.9 → 9.0.0-beta.2

package/src/flex-render.ts

@@ -0,0 +1 @@
+export * from './FlexRender'

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from '@tanstack/table-core'
+
+export * from './FlexRender'
+export * from './Subscribe'
+export * from './createTableHook'
+export * from './useTable'

package/src/legacy.ts

@@ -0,0 +1,3 @@
+// Legacy entry - v8-style API for incremental migration
+// Import flexRender, types (ColumnFiltersState, etc.) from '@tanstack/react-table'
+export * from './useLegacyTable'

package/src/reactivity.ts

@@ -0,0 +1,41 @@
+import { batch, createAtom } from '@tanstack/react-store'
+import type {
+  TableAtomOptions,
+  TableReactivityBindings,
+} from '@tanstack/table-core/reactivity'
+
+/**
+ * Creates the table-core reactivity bindings used by the React adapter.
+ *
+ * React stores table state in TanStack Store atoms and leaves options as plain
+ * resolved data because `useTable` synchronizes options during render.
+ */
+export function reactReactivity(): TableReactivityBindings {
+  return {
+    createOptionsStore: false,
+    wrapExternalAtoms: false,
+    addSubscription: () => {
+      throw new Error(
+        'Feature not supported in current reactivity implementation',
+      )
+    },
+    unmount: () => {
+      throw new Error(
+        'Feature not supported in current reactivity implementation',
+      )
+    },
+    schedule: (fn) => queueMicrotask(fn),
+    batch,
+    untrack: (fn) => fn(),
+    createReadonlyAtom: <T>(fn: () => T, options?: TableAtomOptions<T>) => {
+      return createAtom(() => fn(), {
+        compare: options?.compare,
+      })
+    },
+    createWritableAtom: <T>(value: T, options?: TableAtomOptions<T>) => {
+      return createAtom(value, {
+        compare: options?.compare,
+      })
+    },
+  }
+}

package/src/static-functions.ts

@@ -0,0 +1 @@
+export * from '@tanstack/table-core/static-functions'

package/src/useLegacyTable.ts

@@ -0,0 +1,487 @@
+'use client'
+
+import {
+  aggregationFns,
+  createColumnHelper,
+  createExpandedRowModel,
+  createFacetedMinMaxValues,
+  createFacetedRowModel,
+  createFacetedUniqueValues,
+  createFilteredRowModel,
+  createGroupedRowModel,
+  createPaginatedRowModel,
+  createSortedRowModel,
+  filterFns,
+  sortFns,
+  stockFeatures,
+} from '@tanstack/table-core'
+import { useCallback, useMemo, useState } from 'react'
+import { useTable } from './useTable'
+import type {
+  AggregationFns,
+  Cell,
+  Column,
+  ColumnDef,
+  CreateRowModels_All,
+  FilterFns,
+  Header,
+  HeaderGroup,
+  Row,
+  RowData,
+  RowModel,
+  SortFns,
+  StockFeatures,
+  Table,
+  TableOptions,
+  TableState,
+} from '@tanstack/table-core'
+import type { ReactTable } from './useTable'
+
+// =============================================================================
+// V8-style row model factory functions
+// These are stub functions that act as markers for useLegacyTable to know
+// which row models to enable. They don't actually do anything - the real
+// implementation is handled by useLegacyTable internally.
+// =============================================================================
+
+/**
+ * @deprecated Use `createFilteredRowModel(filterFns)` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the filtered row model.
+ */
+export function getFilteredRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createSortedRowModel(sortFns)` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the sorted row model.
+ */
+export function getSortedRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createPaginatedRowModel()` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the paginated row model.
+ */
+export function getPaginationRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createExpandedRowModel()` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the expanded row model.
+ */
+export function getExpandedRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createGroupedRowModel(aggregationFns)` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the grouped row model.
+ */
+export function getGroupedRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createFacetedRowModel()` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the faceted row model.
+ */
+export function getFacetedRowModel<
+  TData extends RowData,
+>(): FacetedRowModelFactory<TData> {
+  return (() => () => {}) as unknown as FacetedRowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createFacetedMinMaxValues()` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the faceted min/max values.
+ */
+export function getFacetedMinMaxValues<
+  TData extends RowData,
+>(): FacetedMinMaxValuesFactory<TData> {
+  return () => () => undefined
+}
+
+/**
+ * @deprecated Use `createFacetedUniqueValues()` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the faceted unique values.
+ */
+export function getFacetedUniqueValues<
+  TData extends RowData,
+>(): FacetedUniqueValuesFactory<TData> {
+  return () => () => new Map()
+}
+
+/**
+ * @deprecated The core row model is always created automatically in v9.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It does nothing - the core row model is always available.
+ */
+export function getCoreRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+// =============================================================================
+// Type definitions
+// =============================================================================
+
+/**
+ * Row model factory function type from v8 API
+ */
+export type RowModelFactory<TData extends RowData> = (
+  table: Table<StockFeatures, TData>,
+) => () => RowModel<StockFeatures, TData>
+
+/**
+ * Faceted row model factory function type from v8 API
+ */
+export type FacetedRowModelFactory<TData extends RowData> = (
+  table: Table<StockFeatures, TData>,
+  columnId: string,
+) => () => RowModel<StockFeatures, TData>
+
+/**
+ * Faceted min/max values factory function type from v8 API
+ */
+export type FacetedMinMaxValuesFactory<TData extends RowData> = (
+  table: Table<StockFeatures, TData>,
+  columnId: string,
+) => () => undefined | [number, number]
+
+/**
+ * Faceted unique values factory function type from v8 API
+ */
+export type FacetedUniqueValuesFactory<TData extends RowData> = (
+  table: Table<StockFeatures, TData>,
+  columnId: string,
+) => () => Map<any, number>
+
+/**
+ * Legacy v8-style row model options
+ */
+export interface LegacyRowModelOptions<TData extends RowData> {
+  /**
+   * Returns the core row model for the table.
+   * @deprecated This option is no longer needed in v9. The core row model is always created automatically.
+   */
+  getCoreRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the filtered row model for the table.
+   * @deprecated Use `rowModels.filteredRowModel` with `createFilteredRowModel(filterFns)` instead.
+   */
+  getFilteredRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the sorted row model for the table.
+   * @deprecated Use `rowModels.sortedRowModel` with `createSortedRowModel(sortFns)` instead.
+   */
+  getSortedRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the paginated row model for the table.
+   * @deprecated Use `rowModels.paginatedRowModel` with `createPaginatedRowModel()` instead.
+   */
+  getPaginationRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the expanded row model for the table.
+   * @deprecated Use `rowModels.expandedRowModel` with `createExpandedRowModel()` instead.
+   */
+  getExpandedRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the grouped row model for the table.
+   * @deprecated Use `rowModels.groupedRowModel` with `createGroupedRowModel(aggregationFns)` instead.
+   */
+  getGroupedRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the faceted row model for a column.
+   * @deprecated Use `rowModels.facetedRowModel` with `createFacetedRowModel()` instead.
+   */
+  getFacetedRowModel?: FacetedRowModelFactory<TData>
+  /**
+   * Returns the faceted min/max values for a column.
+   * @deprecated Use `rowModels.facetedMinMaxValues` with `createFacetedMinMaxValues()` instead.
+   */
+  getFacetedMinMaxValues?: FacetedMinMaxValuesFactory<TData>
+  /**
+   * Returns the faceted unique values for a column.
+   * @deprecated Use `rowModels.facetedUniqueValues` with `createFacetedUniqueValues()` instead.
+   */
+  getFacetedUniqueValues?: FacetedUniqueValuesFactory<TData>
+  /**
+   * Additional filter functions to apply to the table.
+   * @deprecated Use `rowModels.filteredRowModel` with `createFilteredRowModel(filterFns)` instead.
+   */
+  filterFns?: FilterFns
+  /**
+   * Additional sort functions to apply to the table.
+   * @deprecated Use `rowModels.sortedRowModel` with `createSortedRowModel(sortFns)` instead.
+   */
+  sortFns?: SortFns
+  /**
+   * Additional aggregation functions to apply to the table.
+   * @deprecated Use `rowModels.groupedRowModel` with `createGroupedRowModel(aggregationFns)` instead.
+   */
+  aggregationFns?: AggregationFns
+}
+
+/**
+ * Legacy v8-style table options that work with useLegacyTable.
+ *
+ * This type omits `features` and `rowModels` and instead accepts the v8-style
+ * `get*RowModel` function options.
+ *
+ * @deprecated This is a compatibility layer for migrating from v8. Use `useTable` with explicit `features` and `rowModels` instead.
+ */
+export type LegacyTableOptions<TData extends RowData> = Omit<
+  TableOptions<StockFeatures, TData>,
+  'features' | 'rowModels'
+> &
+  LegacyRowModelOptions<TData>
+
+/**
+ * Legacy table instance type that includes the v8-style `getState()` method.
+ *
+ * @deprecated Use `useTable` with explicit state selection instead.
+ */
+export type LegacyReactTable<TData extends RowData> = ReactTable<
+  StockFeatures,
+  TData,
+  TableState<StockFeatures>
+> & {
+  /**
+   * Returns the current table state.
+   * @deprecated In v9, access state directly via `table.state` or use `table.state` for the full state.
+   */
+  getState: () => TableState<StockFeatures>
+  /**
+   * Sets the current table state.
+   * @deprecated In v9, access state directly via `table.baseAtoms`
+   */
+  setState: (state: TableState<StockFeatures>) => void
+}
+
+// =============================================================================
+// Legacy type aliases - StockFeatures hardcoded for simpler prop typing with useLegacyTable
+// =============================================================================
+
+/** @deprecated Use Column<TFeatures, TData, TValue> with useTable instead. */
+export type LegacyColumn<TData extends RowData, TValue = unknown> = Column<
+  StockFeatures,
+  TData,
+  TValue
+>
+
+/** @deprecated Use Row<TFeatures, TData> with useTable instead. */
+export type LegacyRow<TData extends RowData> = Row<StockFeatures, TData>
+
+/** @deprecated Use Cell<TFeatures, TData, TValue> with useTable instead. */
+export type LegacyCell<TData extends RowData, TValue = unknown> = Cell<
+  StockFeatures,
+  TData,
+  TValue
+>
+
+/** @deprecated Use Header<TFeatures, TData, TValue> with useTable instead. */
+export type LegacyHeader<TData extends RowData, TValue = unknown> = Header<
+  StockFeatures,
+  TData,
+  TValue
+>
+
+/** @deprecated Use HeaderGroup<TFeatures, TData> with useTable instead. */
+export type LegacyHeaderGroup<TData extends RowData> = HeaderGroup<
+  StockFeatures,
+  TData
+>
+
+/** @deprecated Use ColumnDef<TFeatures, TData, TValue> with useTable instead. */
+export type LegacyColumnDef<
+  TData extends RowData,
+  TValue = unknown,
+> = ColumnDef<StockFeatures, TData, TValue>
+
+/** @deprecated Use Table<TFeatures, TData> with useTable instead. */
+export type LegacyTable<TData extends RowData> = Table<StockFeatures, TData>
+
+// =============================================================================
+// Legacy column helper - StockFeatures hardcoded
+// =============================================================================
+
+/**
+ * @deprecated Use `createColumnHelper<TFeatures, TData>()` with useTable instead.
+ *
+ * A column helper with StockFeatures pre-bound for use with useLegacyTable.
+ * Only requires TData—no need to specify TFeatures.
+ */
+export function legacyCreateColumnHelper<TData extends RowData>() {
+  return createColumnHelper<StockFeatures, TData>()
+}
+
+// =============================================================================
+// useLegacyTable hook
+// =============================================================================
+
+/**
+ * @deprecated This hook is provided as a compatibility layer for migrating from TanStack Table v8.
+ *
+ * Use the new `useTable` hook instead with explicit `features` and `rowModels`:
+ *
+ * ```tsx
+ * // New v9 API
+ * const features = tableFeatures({
+ *   columnFilteringFeature,
+ *   rowSortingFeature,
+ *   rowPaginationFeature,
+ * })
+ *
+ * const table = useTable({
+ *   features,
+ *   rowModels: {
+ *     filteredRowModel: createFilteredRowModel(filterFns),
+ *     sortedRowModel: createSortedRowModel(sortFns),
+ *     paginatedRowModel: createPaginatedRowModel(),
+ *   },
+ *   columns,
+ *   data,
+ * })
+ * ```
+ *
+ * Key differences from v8:
+ * - Features are tree-shakeable - only import what you use
+ * - Row models are explicitly passed via `rowModels`
+ * - Use `table.Subscribe` for fine-grained re-renders
+ * - State is accessed via `table.state` after selecting with the 2nd argument
+ *
+ * @param options - Legacy v8-style table options
+ * @returns A table instance with the full state subscribed and a `getState()` method
+ */
+export function useLegacyTable<TData extends RowData>(
+  options: LegacyTableOptions<TData>,
+): LegacyReactTable<TData> {
+  const {
+    // Extract legacy row model options
+    getCoreRowModel: _getCoreRowModel,
+    getFilteredRowModel,
+    getSortedRowModel,
+    getPaginationRowModel,
+    getExpandedRowModel,
+    getGroupedRowModel,
+    getFacetedRowModel,
+    getFacetedMinMaxValues,
+    getFacetedUniqueValues,
+    // Rest of the options
+    ...restOptions
+  } = options
+
+  const [rowModels] = useState(() => {
+    const rowModels: CreateRowModels_All<StockFeatures, TData> = {}
+
+    // Legacy row model options are setup-only. Capture the first render's
+    // marker options to match the table instance lifecycle.
+
+    if (getFilteredRowModel) {
+      rowModels.filteredRowModel = createFilteredRowModel({
+        ...filterFns,
+        ...options.filterFns,
+      })
+    }
+
+    if (getSortedRowModel) {
+      rowModels.sortedRowModel = createSortedRowModel({
+        ...sortFns,
+        ...options.sortFns,
+      })
+    }
+
+    if (getPaginationRowModel) {
+      rowModels.paginatedRowModel = createPaginatedRowModel()
+    }
+
+    if (getExpandedRowModel) {
+      rowModels.expandedRowModel = createExpandedRowModel()
+    }
+
+    if (getGroupedRowModel) {
+      rowModels.groupedRowModel = createGroupedRowModel({
+        ...aggregationFns,
+        ...options.aggregationFns,
+      })
+    }
+
+    if (getFacetedRowModel) {
+      rowModels.facetedRowModel = createFacetedRowModel()
+    }
+
+    if (getFacetedMinMaxValues) {
+      rowModels.facetedMinMaxValues = createFacetedMinMaxValues()
+    }
+
+    if (getFacetedUniqueValues) {
+      rowModels.facetedUniqueValues = createFacetedUniqueValues()
+    }
+
+    return rowModels
+  })
+
+  // Call useTable with the v9 API, subscribing to all state changes
+  const table = useTable<StockFeatures, TData, TableState<StockFeatures>>(
+    {
+      ...restOptions,
+      features: stockFeatures,
+      rowModels,
+    },
+    (state) => state,
+  )
+
+  const getState = useCallback(() => {
+    return table.state
+  }, [table])
+
+  const setState = useCallback(
+    (state: TableState<StockFeatures>) => {
+      Object.entries(state).forEach(([key, value]) => {
+        // @ts-expect-error - baseAtoms is indexed by dynamic string keys
+        table.baseAtoms[key].set(value)
+      })
+    },
+    [table],
+  )
+
+  return useMemo(
+    () => ({
+      ...table,
+      getState,
+      setState,
+    }),
+    [table, getState, setState],
+  )
+}