@tanstack/table-core 9.0.0-alpha.8 → 9.0.0-beta.2

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

@@ -0,0 +1,145 @@
+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'
+
+/**
+ * Computes min and max numeric facet values for one column.
+ *
+ * The configured `facetedMinMaxValues` row-model factory owns the calculation.
+ * If no factory is registered, the result is `undefined`.
+ *
+ * @example
+ * ```ts
+ * const range = column_getFacetedMinMaxValues(column, table)
+ * ```
+ */
+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()
+}
+
+/**
+ * Computes the row model used to derive one column's facet values.
+ *
+ * The faceted row model normally applies every other active filter while
+ * excluding this column's own filter. If no factory is registered, the
+ * pre-filtered row model is returned.
+ *
+ * @example
+ * ```ts
+ * const rows = column_getFacetedRowModel(column, table)
+ * ```
+ */
+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()
+}
+
+/**
+ * Computes unique facet values and their occurrence counts for one column.
+ *
+ * The configured `facetedUniqueValues` row-model factory owns the calculation.
+ * If no factory is registered, an empty `Map` is returned.
+ *
+ * @example
+ * ```ts
+ * const values = column_getFacetedUniqueValues(column, table)
+ * ```
+ */
+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()
+}
+
+/**
+ * Computes min and max numeric facet values for the global filter context.
+ *
+ * The global context is requested with the internal `__global__` column id. If
+ * no factory is registered, the result is `undefined`.
+ *
+ * @example
+ * ```ts
+ * const range = table_getGlobalFacetedMinMaxValues(table)
+ * ```
+ */
+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()
+}
+
+/**
+ * Computes the row model used to derive global facet values.
+ *
+ * The global context is requested with the internal `__global__` column id. If
+ * no faceted row-model factory is registered, the pre-filtered row model is
+ * returned.
+ *
+ * @example
+ * ```ts
+ * const rows = table_getGlobalFacetedRowModel(table)
+ * ```
+ */
+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()
+}
+
+/**
+ * Computes unique values and occurrence counts for the global filter context.
+ *
+ * The global context is requested with the internal `__global__` column id. If
+ * no factory is registered, an empty `Map` is returned.
+ *
+ * @example
+ * ```ts
+ * const values = table_getGlobalFacetedUniqueValues(table)
+ * ```
+ */
+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()
+}

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

@@ -0,0 +1,66 @@
+import { callMemoOrStaticFn, tableMemo } from '../../utils'
+import { column_getFacetedRowModel } from './columnFacetingFeature.utils'
+import type { Row } from '../../types/Row'
+import type { Table, Table_Internal } from '../../types/Table'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { RowData } from '../../types/type-utils'
+
+/**
+ * Creates a memoized faceted min max values helper for faceted filtering.
+ *
+ * The returned function derives facet data from the table row model and relevant filter state so filter UIs can display available values.
+ */
+export function createFacetedMinMaxValues<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+>(): (
+  table: Table<TFeatures, TData>,
+  columnId: string,
+) => () => undefined | [number, number] {
+  return (_table, columnId) => {
+    const table: Table_Internal<TFeatures, TData> = _table
+    return tableMemo({
+      feature: 'columnFacetingFeature',
+      fn: (flatRows) => _createFacetedMinMaxValues(columnId, flatRows),
+      fnName: 'table.getFacetedMinMaxValues',
+      memoDeps: () => {
+        const column = table.getColumn(columnId)
+        if (!column) return [table.getPreFilteredRowModel().flatRows]
+        return [
+          callMemoOrStaticFn(
+            column,
+            'getFacetedRowModel',
+            column_getFacetedRowModel,
+            table,
+          ).flatRows,
+        ]
+      },
+      table,
+    })
+  }
+}
+
+function _createFacetedMinMaxValues<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+>(
+  columnId: string,
+  flatRows: Array<Row<TFeatures, TData>>,
+): undefined | [number, number] {
+  if (!flatRows.length) return undefined
+
+  let facetedMinValue = Number.POSITIVE_INFINITY
+  let facetedMaxValue = Number.NEGATIVE_INFINITY
+  let foundAny = false
+
+  for (let i = 0; i < flatRows.length; i++) {
+    const value = Number(flatRows[i]!.getValue(columnId))
+    if (Number.isNaN(value)) continue
+    foundAny = true
+    if (value < facetedMinValue) facetedMinValue = value
+    if (value > facetedMaxValue) facetedMaxValue = value
+  }
+
+  if (!foundAny) return undefined
+  return [facetedMinValue, facetedMaxValue]
+}

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

@@ -0,0 +1,85 @@
+import { tableMemo } from '../../utils'
+import { filterRows } from '../column-filtering/filterRowsUtils'
+import type { Table, Table_Internal } from '../../types/Table'
+import type {
+  ColumnFiltersState,
+  Row_ColumnFiltering,
+} from '../column-filtering/columnFilteringFeature.types'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
+import type { Row } from '../../types/Row'
+import type { RowData } from '../../types/type-utils'
+
+/**
+ * Creates a memoized faceted row model factory.
+ *
+ * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
+ */
+export function createFacetedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+>(): (
+  table: Table<TFeatures, TData>,
+  columnId: string,
+) => () => RowModel<TFeatures, TData> {
+  return (_table, columnId) => {
+    const table: Table_Internal<TFeatures, TData> = _table
+    return tableMemo({
+      feature: 'columnFacetingFeature',
+      table,
+      fnName: 'createFacetedRowModel',
+      memoDeps: () => [
+        table.getPreFilteredRowModel(),
+        table.atoms.columnFilters?.get(),
+        table.atoms.globalFilter?.get(),
+        table.getFilteredRowModel(),
+      ],
+      fn: (preRowModel, columnFilters, globalFilter) =>
+        _createFacetedRowModel(
+          table,
+          columnId,
+          preRowModel,
+          columnFilters,
+          globalFilter,
+        ),
+    })
+  }
+}
+
+function _createFacetedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+>(
+  table: Table_Internal<TFeatures, TData>,
+  columnId: string,
+  preRowModel: RowModel<TFeatures, TData>,
+  columnFilters?: ColumnFiltersState,
+  globalFilter?: string,
+) {
+  if (!preRowModel.rows.length || (!columnFilters?.length && !globalFilter)) {
+    return preRowModel
+  }
+
+  const filterableIds: Array<string> = []
+  if (columnFilters) {
+    for (let i = 0; i < columnFilters.length; i++) {
+      const id = columnFilters[i]!.id
+      if (id !== columnId) filterableIds.push(id)
+    }
+  }
+  if (globalFilter) filterableIds.push('__global__')
+
+  const filterRowsImpl = (
+    row: Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>,
+  ) => {
+    // Horizontally filter rows through each column
+    for (let i = 0; i < filterableIds.length; i++) {
+      if (row.columnFilters?.[filterableIds[i]!] === false) {
+        return false
+      }
+    }
+    return true
+  }
+
+  return filterRows(preRowModel.rows, filterRowsImpl, table)
+}

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

@@ -0,0 +1,66 @@
+import { callMemoOrStaticFn, tableMemo } from '../../utils'
+import { column_getFacetedRowModel } from './columnFacetingFeature.utils'
+import type { Row } from '../../types/Row'
+import type { Table, Table_Internal } from '../../types/Table'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { RowData } from '../../types/type-utils'
+
+/**
+ * Creates a memoized faceted unique values helper for faceted filtering.
+ *
+ * The returned function derives facet data from the table row model and relevant filter state so filter UIs can display available values.
+ */
+export function createFacetedUniqueValues<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+>(): (
+  table: Table<TFeatures, TData>,
+  columnId: string,
+) => () => Map<any, number> {
+  return (_table, columnId) => {
+    const table: Table_Internal<TFeatures, TData> = _table
+    return tableMemo({
+      feature: 'columnFacetingFeature',
+      table,
+      fnName: 'table.getFacetedUniqueValues',
+      memoDeps: () => {
+        const column = table.getColumn(columnId)
+        if (!column) return [table.getPreFilteredRowModel().flatRows]
+        return [
+          callMemoOrStaticFn(
+            column,
+            'getFacetedRowModel',
+            column_getFacetedRowModel,
+            table,
+          ).flatRows,
+        ]
+      },
+      fn: (flatRows) => _createFacetedUniqueValues(columnId, flatRows),
+    })
+  }
+}
+
+function _createFacetedUniqueValues<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+>(columnId: string, flatRows: Array<Row<TFeatures, TData>>): Map<any, number> {
+  const facetedUniqueValues = new Map<any, number>()
+
+  for (let i = 0; i < flatRows.length; i++) {
+    const values = flatRows[i]!.getUniqueValues(columnId)
+
+    for (let j = 0; j < values.length; j++) {
+      const value = values[j]
+      if (facetedUniqueValues.has(value)) {
+        facetedUniqueValues.set(
+          value,
+          (facetedUniqueValues.get(value) ?? 0) + 1,
+        )
+      } else {
+        facetedUniqueValues.set(value, 1)
+      }
+    }
+  }
+
+  return facetedUniqueValues
+}

package/src/features/column-filtering/columnFilteringFeature.ts

@@ -0,0 +1,129 @@
+import {
+  assignPrototypeAPIs,
+  assignTableAPIs,
+  makeStateUpdater,
+} from '../../utils'
+import {
+  column_getAutoFilterFn,
+  column_getCanFilter,
+  column_getFilterFn,
+  column_getFilterIndex,
+  column_getFilterValue,
+  column_getIsFiltered,
+  column_setFilterValue,
+  getDefaultColumnFiltersState,
+  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
+}
+
+/**
+ * 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.
+ */
+export function constructColumnFilteringFeature<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(): TableFeature<ColumnFilteringFeatureConstructors<TFeatures, TData>> {
+  return {
+    getInitialState: (initialState) => {
+      return {
+        columnFilters: getDefaultColumnFiltersState(),
+        ...initialState,
+      }
+    },
+
+    getDefaultColumnDef: () => {
+      return {
+        filterFn: 'auto',
+      }
+    },
+
+    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),
+        },
+      })
+    },
+
+    initRowInstanceData: (row) => {
+      ;(row as any).columnFilters = {}
+      ;(row as any).columnFiltersMeta = {}
+    },
+
+    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()