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

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

@@ -0,0 +1,63 @@
+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'
+
+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
+
+  const numericValues = flatRows
+    .map((flatRow) => flatRow.getValue(columnId))
+    .map(Number)
+    .filter((value) => !Number.isNaN(value))
+
+  if (!numericValues.length) return undefined
+
+  let facetedMinValue = numericValues[0]!
+  let facetedMaxValue = numericValues[0]!
+
+  for (const value of numericValues) {
+    if (value < facetedMinValue) facetedMinValue = value
+    if (value > facetedMaxValue) facetedMaxValue = value
+  }
+
+  return [facetedMinValue, facetedMaxValue]
+}

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

@@ -0,0 +1,76 @@
+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'
+
+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 = [
+    ...(columnFilters?.map((d) => d.id).filter((d) => d !== columnId) ?? []),
+    globalFilter ? '__global__' : undefined,
+  ].filter(Boolean) as Array<string>
+
+  const filterRowsImpl = (
+    row: Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>,
+  ) => {
+    // Horizontally filter rows through each column
+    for (const colId of filterableIds) {
+      if (row.columnFilters?.[colId] === false) {
+        return false
+      }
+    }
+    return true
+  }
+
+  return filterRows(preRowModel.rows, filterRowsImpl, table)
+}

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

@@ -0,0 +1,60 @@
+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'
+
+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 (const row of flatRows) {
+    const values = row.getUniqueValues(columnId)
+
+    for (const value of values) {
+      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,121 @@
+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
+}
+
+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 Column Filtering feature adds column filtering state and APIs to the table, row, and column objects.
+ * **Note:** This does not include Global Filtering. The globalFilteringFeature feature has been split out into its own standalone feature.
+ */
+export const columnFilteringFeature = constructColumnFilteringFeature()

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

@@ -0,0 +1,219 @@
+import type { Table } from '../../types/Table'
+import type { BuiltInFilterFn } from '../../fns/filterFns'
+import type {
+  CellData,
+  OnChangeFn,
+  RowData,
+  Updater,
+} from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
+import type { Row } from '../../types/Row'
+import type { Column } from '../../types/Column'
+
+export interface FilterMeta {}
+
+export interface FilterFns {}
+
+export interface TableState_ColumnFiltering {
+  columnFilters: ColumnFiltersState
+}
+
+export type ColumnFiltersState = Array<ColumnFilter>
+
+export interface ColumnFilter {
+  id: string
+  value: unknown
+}
+
+export interface ResolvedColumnFilter<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  filterFn: FilterFn<TFeatures, TData>
+  id: string
+  resolvedValue: unknown
+}
+
+export interface RowModelFns_ColumnFiltering<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  filterFns: Record<keyof FilterFns, FilterFn<TFeatures, TData>>
+}
+
+export interface FilterFn<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  (
+    row: Row<TFeatures, TData>,
+    columnId: string,
+    filterValue: any,
+    addMeta?: (meta: FilterMeta) => void,
+  ): boolean
+  autoRemove?: ColumnFilterAutoRemoveTestFn<TFeatures, TData>
+  resolveFilterValue?: TransformFilterValueFn<TFeatures, TData>
+}
+
+export type TransformFilterValueFn<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+> = (value: any, column?: Column<TFeatures, TData, TValue>) => TValue
+
+export type ColumnFilterAutoRemoveTestFn<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+> = (value: any, column?: Column<TFeatures, TData, TValue>) => boolean
+
+export type CustomFilterFns<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = Record<string, FilterFn<TFeatures, TData>>
+
+export type FilterFnOption<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = 'auto' | BuiltInFilterFn | keyof FilterFns | FilterFn<TFeatures, TData>
+
+export interface ColumnDef_ColumnFiltering<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Enables/disables the **column** filter for this column.
+   */
+  enableColumnFilter?: boolean
+  /**
+   * The filter function to use with this column. Can be the name of a built-in filter function or a custom filter function.
+   */
+  filterFn?: FilterFnOption<TFeatures, TData>
+}
+
+export interface Column_ColumnFiltering<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Returns an automatically calculated filter function for the column based off of the columns first known value.
+   */
+  getAutoFilterFn: () => FilterFn<TFeatures, TData>
+  /**
+   * Returns whether or not the column can be **column** filtered.
+   */
+  getCanFilter: () => boolean
+  /**
+   * Returns the filter function (either user-defined or automatic, depending on configuration) for the columnId specified.
+   */
+  getFilterFn: () => FilterFn<TFeatures, TData>
+  /**
+   * Returns the index (including `-1`) of the column filter in the table's `state.columnFilters` array.
+   */
+  getFilterIndex: () => number
+  /**
+   * Returns the current filter value for the column.
+   */
+  getFilterValue: () => unknown
+  /**
+   * Returns whether or not the column is currently filtered.
+   */
+  getIsFiltered: () => boolean
+  /**
+   * A function that sets the current filter value for the column. You can pass it a value or an updater function for immutability-safe operations on existing values.
+   */
+  setFilterValue: (updater: Updater<any>) => void
+}
+
+export interface Row_ColumnFiltering<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * The column filters map for the row. This object tracks whether a row is passing/failing specific filters by their column ID.
+   */
+  columnFilters: Record<string, boolean>
+  /**
+   * The column filters meta map for the row. This object tracks any filter meta for a row as optionally provided during the filtering process.
+   */
+  columnFiltersMeta: Record<string, FilterMeta>
+}
+
+export interface TableOptions_ColumnFiltering<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Enables/disables **column** filtering for all columns.
+   */
+  enableColumnFilters?: boolean
+  /**
+   * Enables/disables all filtering for the table.
+   */
+  enableFilters?: boolean
+  /**
+   * By default, filtering is done from parent rows down (so if a parent row is filtered out, all of its children will be filtered out as well). Setting this option to `true` will cause filtering to be done from leaf rows up (which means parent rows will be included so long as one of their child or grand-child rows is also included).
+   */
+  filterFromLeafRows?: boolean
+  /**
+   * Disables the `getFilteredRowModel` from being used to filter data. This may be useful if your table needs to dynamically support both client-side and server-side filtering.
+   */
+  manualFiltering?: boolean
+  /**
+     * By default, filtering is done for all rows (max depth of 100), no matter if they are root level parent rows or the child leaf rows of a parent row. Setting this option to `0` will cause filtering to only be applied to the root level parent rows, with all sub-rows remaining unfiltered. Similarly, setting this option to `1` will cause filtering to only be applied to child leaf rows 1 level deep, and so on.
+
+     * This is useful for situations where you want a row's entire child hierarchy to be visible regardless of the applied filter.
+     */
+  maxLeafRowFilterDepth?: number
+  /**
+   * If provided, this function will be called with an `updaterFn` when `state.columnFilters` changes. This overrides the default internal state management, so you will need to persist the state change either fully or partially outside of the table.
+   */
+  onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>
+}
+
+export interface Table_ColumnFiltering {
+  /**
+   * Resets the **columnFilters** state to `initialState.columnFilters`, or `true` can be passed to force a default blank state reset to `[]`.
+   */
+  resetColumnFilters: (defaultState?: boolean) => void
+  /**
+   * Sets or updates the `state.columnFilters` state.
+   */
+  setColumnFilters: (updater: Updater<ColumnFiltersState>) => void
+}
+
+export interface Table_RowModels_Filtered<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Returns the row model for the table after **column** filtering has been applied.
+   */
+  getFilteredRowModel: () => RowModel<TFeatures, TData>
+  /**
+   * Returns the row model for the table before any **column** filtering has been applied.
+   */
+  getPreFilteredRowModel: () => RowModel<TFeatures, TData>
+}
+
+export interface CreateRowModel_Filtered<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * If provided, this function is called **once** per table and should return a **new function** which will calculate and return the row model for the table when it's filtered.
+   * - For server-side filtering, this function is unnecessary and can be ignored since the server should already return the filtered row model.
+   * - For client-side filtering, this function is required. A default implementation is provided via any table adapter's `{ getFilteredRowModel }` export.
+   */
+  filteredRowModel?: (
+    table: Table<TFeatures, TData>,
+  ) => () => RowModel<TFeatures, TData>
+}
+
+export interface CachedRowModel_Filtered<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  filteredRowModel: () => RowModel<TFeatures, TData>
+}