@tanstack/table-core 9.0.0-alpha.4 → 9.0.0-alpha.42

package/src/core/table/constructTable.ts

@@ -0,0 +1,126 @@
+import { coreFeatures } from '../coreFeatures'
+import { cloneState } from '../../utils'
+import { atomToStore } from '../reactivity/coreReactivityFeature.utils'
+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'
+
+export function getInitialTableState<TFeatures extends TableFeatures>(
+  features: TFeatures,
+  initialState: Partial<TableState<TFeatures>> | undefined = {},
+): TableState<TFeatures> {
+  Object.values(features).forEach((feature) => {
+    initialState = feature.getInitialState?.(initialState) ?? initialState
+  })
+  return cloneState(initialState) as TableState<TFeatures>
+}
+
+export function constructTable<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData> {
+  const _reactivity = tableOptions._features.coreReativityFeature!
+
+  const table = {
+    _reactivity,
+    _features: { ...coreFeatures, ...tableOptions._features },
+    _rowModels: {},
+    _rowModelFns: {},
+    get options() {
+      return this.optionsStore.get()
+    },
+    set options(value) {
+      this.optionsStore.set(() => value)
+    },
+    baseAtoms: {},
+    atoms: {},
+  } as Table_Internal<TFeatures, TData>
+
+  const featuresList: Array<TableFeature<{}>> = Object.values(table._features)
+
+  const defaultOptions = featuresList.reduce((obj, feature) => {
+    return Object.assign(obj, feature.getDefaultTableOptions?.(table))
+  }, {}) as TableOptions<TFeatures, TData>
+
+  // @ts-ignore - direct set
+  table.optionsStore = _reactivity.createWritableAtom<
+    TableOptions<TFeatures, TData>
+  >({ ...defaultOptions, ...tableOptions }, { debugName: 'table/optionsStore' })
+
+  table.initialState = getInitialTableState(
+    table._features,
+    table.options.initialState,
+  )
+
+  const stateKeys = Object.keys(table.initialState) as Array<
+    string & keyof TableState<TFeatures>
+  >
+
+  for (const key of stateKeys) {
+    // create writable base atom
+    table.baseAtoms[key] = _reactivity.createWritableAtom(
+      table.initialState[key],
+      {
+        debugName: `table/baseAtoms/${key}`,
+      },
+    ) as any
+
+    // create readonly derived atom: on each get(), read current options (state, then external atom, then base)
+    ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(
+      () => {
+        // Reading optionsStore.get() keeps this reactive to setOptions
+        const opts = table.optionsStore.get()
+        const state = opts.state
+        if (key in (state ?? {})) {
+          return state![key]
+        }
+        const externalAtom = opts.atoms?.[key]
+        if (externalAtom) {
+          return externalAtom.get()
+        }
+        return table.baseAtoms[key].get()
+      },
+      { debugName: `table/atoms/${key}` },
+    )
+  }
+
+  table.store = atomToStore(
+    _reactivity.createReadonlyAtom(
+      () => {
+        const snapshot = {} as TableState<TFeatures>
+        for (const key of stateKeys) {
+          snapshot[key] = table.atoms[key].get()
+        }
+        return snapshot
+      },
+      { debugName: 'table/store' },
+    ),
+  )
+
+  if (
+    process.env.NODE_ENV === 'development' &&
+    (tableOptions.debugAll || tableOptions.debugTable)
+  ) {
+    const features = Object.keys(table._features)
+    const rowModels = Object.keys(table.options._rowModels || {})
+    const states = Object.keys(table.initialState)
+
+    console.log(
+      `Constructing Table Instance
+
+  Features:   ${features.join('\n              ')}
+
+  Row Models: ${rowModels.length ? rowModels.join('\n              ') : '(none)'}
+
+  States:     ${states.join('\n              ')}`,
+    )
+  }
+
+  for (const feature of featuresList) {
+    feature.constructTableAPIs?.(table)
+  }
+
+  return table
+}

package/src/core/table/coreTablesFeature.ts

@@ -0,0 +1,36 @@
+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>
+}
+
+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),
+        },
+      })
+    },
+  }
+}
+
+/**
+ * The Core Tables feature provides the core table functionality for handling state and options.
+ */
+export const coreTablesFeature = constructCoreTablesFeature()

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

@@ -0,0 +1,192 @@
+import type { TableReactivityBindings } from '../reactivity/coreReactivityFeature.types'
+import type { Atom, ReadonlyAtom, ReadonlyStore } from '@tanstack/store'
+import type { CoreFeatures } from '../coreFeatures'
+import type { RowModelFns } from '../../types/RowModelFns'
+import type { RowData, Updater } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { CachedRowModels, CreateRowModels_All } from '../../types/RowModel'
+import type { TableOptions } from '../../types/TableOptions'
+import type { TableState, TableState_All } from '../../types/TableState'
+
+export interface TableMeta<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {}
+
+/**
+ * A map of writable atoms, one per `TableState` slice. These are the internal
+ * writable atoms that the library always writes to via `makeStateUpdater`.
+ */
+export type BaseAtoms<TFeatures extends TableFeatures> = {
+  [K in keyof TableState<TFeatures>]-?: Atom<TableState<TFeatures>[K]>
+}
+
+/**
+ * A map of readonly derived atoms, one per `TableState` slice. Each derives
+ * from its corresponding `baseAtom` plus, optionally, a per-slice external
+ * atom or external state value.
+ *
+ * Precedence: `options.atoms[key]` > `options.state[key]` > `baseAtoms[key]`.
+ */
+export type Atoms<TFeatures extends TableFeatures> = {
+  [K in keyof TableState<TFeatures>]-?: ReadonlyAtom<TableState<TFeatures>[K]>
+}
+
+/**
+ * A map of optional external atoms, one per `TableState` slice. Consumers can
+ * provide their own writable atom for any state slice to take over ownership
+ * of that slice.
+ */
+export type ExternalAtoms<TFeatures extends TableFeatures> = Partial<{
+  [K in keyof TableState<TFeatures>]: Atom<TableState<TFeatures>[K]>
+}>
+
+/**
+ * Internal "all features" flat variants of the atom types. `Table_Internal`
+ * uses these so feature code (written generically over `TFeatures`) can access
+ * any slice atom (e.g. `table.atoms.columnPinning`) without TypeScript
+ * narrowing away slices that aren't in the current `TFeatures` union.
+ *
+ * Keys are optional: feature code can read atoms from slices it doesn't own,
+ * but those slices may not be registered on the current table. Consumers must
+ * use optional chaining (`table.atoms.columnPinning?.get() ?? default`).
+ */
+export type BaseAtoms_All = {
+  [K in keyof TableState_All]?: Atom<TableState_All[K]>
+}
+export type Atoms_All = {
+  [K in keyof TableState_All]?: ReadonlyAtom<TableState_All[K]>
+}
+export type ExternalAtoms_All = Partial<{
+  [K in keyof TableState_All]: Atom<TableState_All[K]>
+}>
+
+export interface TableOptions_Table<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * The features that you want to enable for the table.
+   */
+  readonly _features: TFeatures
+  /**
+   * The row model options that you want to enable for the table.
+   */
+  readonly _rowModels?: CreateRowModels_All<TFeatures, TData>
+  /**
+   * Optionally, provide your own external writable atoms for individual state slices.
+   * When an atom is provided for a given slice, it takes precedence over `options.state[key]`
+   * and the internal base atom for that slice. Writes originating from the library are
+   * still routed through the internal base atom; consumers are responsible for
+   * mirroring changes back to their external atom via the corresponding `onXChange` callback.
+   */
+  readonly atoms?: ExternalAtoms<TFeatures>
+  /**
+   * Set this option to override any of the `autoReset...` feature options.
+   */
+  readonly autoResetAll?: boolean
+  /**
+   * The data for the table to display. When the `data` option changes reference, the table will reprocess the data.
+   */
+  readonly data: ReadonlyArray<TData>
+  /**
+   * Use this option to optionally pass initial state to the table. This state will be used when resetting various table states either automatically by the table (eg. `options.autoResetPageIndex`) or via functions like `table.resetRowSelection()`. Most reset function allow you optionally pass a flag to reset to a blank/default state instead of the initial state.
+   * Table state will not be reset when this object changes, which also means that the initial state object does not need to be stable.
+   */
+  readonly initialState?: Partial<TableState<TFeatures>>
+  /**
+   * This option is used to optionally implement the merging of table options.
+   */
+  readonly mergeOptions?: (
+    defaultOptions: TableOptions<TFeatures, TData>,
+    options: Partial<TableOptions<TFeatures, TData>>,
+  ) => TableOptions<TFeatures, TData>
+  /**
+   * You can pass any object to `options.meta` and access it anywhere the `table` is available via `table.options.meta`.
+   */
+  readonly meta?: TableMeta<TFeatures, TData>
+  /**
+   * Pass in individual self-managed state to the table.
+   */
+  readonly state?: Partial<TableState<TFeatures>>
+}
+
+export interface Table_CoreProperties<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Table reactivity bindings for interacting with TanStack Store.
+   */
+  readonly _reactivity: TableReactivityBindings
+  /**
+   * Prototype cache for Cell objects - shared by all cells in this table
+   */
+  _cellPrototype?: object
+  /**
+   * Prototype cache for Column objects - shared by all columns in this table
+   */
+  _columnPrototype?: object
+  /**
+   * The features that are enabled for the table.
+   */
+  readonly _features: Partial<CoreFeatures> & TFeatures
+  /**
+   * Prototype cache for Header objects - shared by all headers in this table
+   */
+  _headerPrototype?: object
+  /**
+   * The row model processing functions that are used to process the data by features.
+   */
+  readonly _rowModelFns: RowModelFns<TFeatures, TData>
+  /**
+   * The row models that are enabled for the table.
+   */
+  readonly _rowModels: CachedRowModels<TFeatures, TData>
+  /**
+   * Prototype cache for Row objects - shared by all rows in this table
+   */
+  _rowPrototype?: object
+  /**
+   * The readonly derived atoms for each `TableState` slice. Each derives from
+   * its corresponding `baseAtom` plus, optionally, a per-slice external atom or
+   * external state value (precedence: external atom > external state > base atom).
+   */
+  readonly atoms: Atoms<TFeatures>
+  /**
+   * The internal writable atoms for each `TableState` slice. This is the library's
+   * single write surface — all state mutations from features land here.
+   */
+  readonly baseAtoms: BaseAtoms<TFeatures>
+  /**
+   * This is the resolved initial state of the table.
+   */
+  readonly initialState: TableState<TFeatures>
+  /**
+   * A read-only reference to the table's current options.
+   */
+  readonly options: TableOptions<TFeatures, TData>
+  /**
+   * The base store for the table options.
+   */
+  readonly optionsStore: Atom<TableOptions<TFeatures, TData>>
+  /**
+   * The readonly flat store for the table state. Derives from `table.atoms`
+   * only; never reads external state directly.
+   */
+  readonly store: ReadonlyStore<TableState<TFeatures>>
+}
+
+export interface Table_Table<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> extends Table_CoreProperties<TFeatures, TData> {
+  /**
+   * Call this function to reset the table state to the initial state.
+   */
+  reset: () => void
+  /**
+   * This function can be used to update the table options.
+   */
+  setOptions: (newOptions: Updater<TableOptions<TFeatures, TData>>) => void
+}

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

@@ -0,0 +1,46 @@
+import { cloneState, functionalUpdate } from '../../utils'
+import type { RowData, Updater } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { Table_Internal } from '../../types/Table'
+import type { TableOptions } from '../../types/TableOptions'
+
+export function table_reset<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): void {
+  const snap = cloneState(table.initialState)
+  table._reactivity.batch(() => {
+    for (const key of Object.keys(snap) as Array<keyof typeof snap>) {
+      ;(table.baseAtoms as any)[key].set(snap[key] as any)
+    }
+  })
+}
+
+export function table_mergeOptions<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  table: Table_Internal<TFeatures, TData>,
+  newOptions: TableOptions<TFeatures, TData>,
+) {
+  if (table.options.mergeOptions) {
+    return table.options.mergeOptions(table.options, newOptions)
+  }
+
+  return {
+    ...table.options,
+    ...newOptions,
+  }
+}
+
+export function table_setOptions<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  table: Table_Internal<TFeatures, TData>,
+  updater: Updater<TableOptions<TFeatures, TData>>,
+): void {
+  const newOptions = functionalUpdate(updater, table.options)
+  const mergedOptions = table_mergeOptions(table, newOptions)
+  table.optionsStore.set(() => mergedOptions)
+}

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

@@ -0,0 +1,112 @@
+import {
+  assignPrototypeAPIs,
+  assignTableAPIs,
+  callMemoOrStaticFn,
+} from '../../utils'
+import {
+  column_getFacetedMinMaxValues,
+  column_getFacetedRowModel,
+  column_getFacetedUniqueValues,
+  table_getGlobalFacetedMinMaxValues,
+  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>
+}
+
+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),
+        },
+      })
+    },
+
+    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 Column Faceting feature adds column faceting APIs to the column objects.
+ */
+export const columnFacetingFeature = constructColumnFacetingFeature()

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

@@ -0,0 +1,97 @@
+import type { Table } from '../../types/Table'
+import type { RowData } from '../../types/type-utils'
+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,
+> {
+  /**
+   * A function that **computes and returns** a min/max tuple derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.
+   */
+  getFacetedMinMaxValues: () => undefined | [number, number]
+  /**
+   * A function that **computes and returns** a row model with all other column filters applied, excluding its own filter. Useful for displaying faceted result counts.
+   */
+  getFacetedRowModel: () => RowModel<TFeatures, TData>
+  /**
+   * Returns a `Map` of unique values and their occurrences derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.
+   */
+  getFacetedUniqueValues: () => Map<any, number>
+}
+
+export interface Table_RowModels_Faceted<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * A function that **computes and returns** a min/max tuple derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.
+   * > ⚠️ Requires that you pass a valid `getFacetedMinMaxValues` function to `options.getFacetedMinMaxValues`. A default implementation is provided via the exported `getFacetedMinMaxValues` function.
+   */
+  getFacetedMinMaxValues: () => undefined | [number, number]
+  /**
+   * Returns the row model with all other column filters applied, excluding its own filter. Useful for displaying faceted result counts.
+   * > ⚠️ Requires that you pass a valid `getFacetedRowModel` function to `options.facetedRowModel`. A default implementation is provided via the exported `getFacetedRowModel` function.
+   */
+  getFacetedRowModel: () => RowModel<TFeatures, TData>
+  /**
+   * A function that **computes and returns** a `Map` of unique values and their occurrences derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.
+   * > ⚠️ Requires that you pass a valid `getFacetedUniqueValues` function to `options.getFacetedUniqueValues`. A default implementation is provided via the exported `getFacetedUniqueValues` function.
+   */
+  getFacetedUniqueValues: () => Map<any, number>
+}
+
+export interface CreateRowModel_Faceted<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * This function is used to retrieve the faceted min/max values. If using server-side faceting, this function is not required. To use client-side faceting, pass the exported `getFacetedMinMaxValues()` from your adapter to your table or implement your own.
+   */
+  facetedMinMaxValues?: (
+    table: Table<TFeatures, TData>,
+    columnId: string,
+  ) => () => [number, number] | undefined
+  /**
+   * This function is used to retrieve the faceted row model. If using server-side faceting, this function is not required. To use client-side faceting, pass the exported `getFacetedRowModel()` from your adapter to your table or implement your own.
+   */
+  facetedRowModel?: (
+    table: Table<TFeatures, TData>,
+    columnId: string,
+  ) => () => RowModel<TFeatures, TData>
+  /**
+   * This function is used to retrieve the faceted unique values. If using server-side faceting, this function is not required. To use client-side faceting, pass the exported `getFacetedUniqueValues()` from your adapter to your table or implement your own.
+   */
+  facetedUniqueValues?: (
+    table: Table<TFeatures, TData>,
+    columnId: string,
+  ) => () => Map<any, number>
+}
+
+export interface CachedRowModel_Faceted<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  facetedRowModel?: (columnId: string) => () => RowModel<TFeatures, TData>
+  facetedMinMaxValues?: (columnId: string) => [number, number]
+  facetedUniqueValues?: (columnId: string) => Map<any, number>
+}
+
+export interface Table_ColumnFaceting<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Returns the min and max values for the global filter.
+   */
+  getGlobalFacetedMinMaxValues: () => undefined | [number, number]
+  /**
+   * Returns the row model for the table after **global** filtering has been applied.
+   */
+  getGlobalFacetedRowModel: () => RowModel<TFeatures, TData>
+  /**
+   * Returns the faceted unique values for the global filter.
+   */
+  getGlobalFacetedUniqueValues: () => Map<any, number>
+}

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

@@ -0,0 +1,77 @@
+import type { CellData, RowData } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
+import type { Table_Internal } from '../../types/Table'
+import type { Column_Internal } from '../../types/Column'
+
+export function column_getFacetedMinMaxValues<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+>(
+  column: Column_Internal<TFeatures, TData, TValue>,
+  table: Table_Internal<TFeatures, TData>,
+): [number, number] | undefined {
+  const facetedMinMaxValuesFn =
+    table.options._rowModels?.facetedMinMaxValues?.(table, column.id) ??
+    (() => undefined)
+  return facetedMinMaxValuesFn()
+}
+
+export function column_getFacetedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+>(
+  column: Column_Internal<TFeatures, TData, TValue> | undefined,
+  table: Table_Internal<TFeatures, TData>,
+): RowModel<TFeatures, TData> {
+  const facetedRowModelFn =
+    table.options._rowModels?.facetedRowModel?.(table, column?.id ?? '') ??
+    (() => table.getPreFilteredRowModel())
+  return facetedRowModelFn()
+}
+
+export function column_getFacetedUniqueValues<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+>(
+  column: Column_Internal<TFeatures, TData, TValue>,
+  table: Table_Internal<TFeatures, TData>,
+): Map<any, number> {
+  const facetedUniqueValuesFn =
+    table.options._rowModels?.facetedUniqueValues?.(table, column.id) ??
+    (() => new Map<any, number>())
+  return facetedUniqueValuesFn()
+}
+
+export function table_getGlobalFacetedMinMaxValues<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): undefined | [number, number] {
+  const facetedMinMaxValuesFn =
+    table.options._rowModels?.facetedMinMaxValues?.(table, '__global__') ??
+    (() => undefined)
+  return facetedMinMaxValuesFn()
+}
+
+export function table_getGlobalFacetedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  const facetedRowModelFn =
+    table.options._rowModels?.facetedRowModel?.(table, '__global__') ??
+    (() => table.getPreFilteredRowModel())
+  return facetedRowModelFn()
+}
+
+export function table_getGlobalFacetedUniqueValues<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): Map<any, number> {
+  const facetedUniqueValuesFn =
+    table.options._rowModels?.facetedUniqueValues?.(table, '__global__') ??
+    (() => new Map())
+  return facetedUniqueValuesFn()
+}