@tanstack/table-core 9.0.0-beta.52 → 9.0.0-beta.53

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

@@ -1,180 +0,0 @@
-import { makeObjectMap } from '../../utils'
-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 facetedMinMaxValues = (table._rowModels.facetedMinMaxValues ??=
-    makeObjectMap())
-  let facetedMinMaxValuesFn = facetedMinMaxValues[column.id]
-
-  if (!facetedMinMaxValuesFn) {
-    facetedMinMaxValuesFn = facetedMinMaxValues[column.id] =
-      table.options.features.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 columnId = column?.id ?? ''
-  const facetedRowModels = (table._rowModels.facetedRowModels ??=
-    makeObjectMap())
-  let facetedRowModelFn = facetedRowModels[columnId]
-
-  if (!facetedRowModelFn) {
-    facetedRowModelFn = facetedRowModels[columnId] =
-      table.options.features.facetedRowModel?.(table, columnId) ??
-      (() => 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 facetedUniqueValues = (table._rowModels.facetedUniqueValues ??=
-    makeObjectMap())
-  let facetedUniqueValuesFn = facetedUniqueValues[column.id]
-
-  if (!facetedUniqueValuesFn) {
-    facetedUniqueValuesFn = facetedUniqueValues[column.id] =
-      table.options.features.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] {
-  if (!table._rowModels.globalFacetedMinMaxValues) {
-    table._rowModels.globalFacetedMinMaxValues =
-      table.options.features.facetedMinMaxValues?.(table, '__global__') ??
-      (() => undefined)
-  }
-
-  const facetedMinMaxValuesFn = table._rowModels.globalFacetedMinMaxValues
-  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> {
-  if (!table._rowModels.globalFacetedRowModel) {
-    table._rowModels.globalFacetedRowModel =
-      table.options.features.facetedRowModel?.(table, '__global__') ??
-      (() => table.getPreFilteredRowModel())
-  }
-
-  const facetedRowModelFn = table._rowModels.globalFacetedRowModel
-  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> {
-  if (!table._rowModels.globalFacetedUniqueValues) {
-    table._rowModels.globalFacetedUniqueValues =
-      table.options.features.facetedUniqueValues?.(table, '__global__') ??
-      (() => new Map())
-  }
-
-  const facetedUniqueValuesFn = table._rowModels.globalFacetedUniqueValues
-  return facetedUniqueValuesFn()
-}

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

@@ -1,92 +0,0 @@
-import { callMemoOrStaticFn, tableMemo } from '../../utils'
-import { column_getCanGlobalFilter } from '../global-filtering/globalFilteringFeature.utils'
-import {
-  column_getFacetedRowModel,
-  table_getGlobalFacetedRowModel,
-} 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 as unknown as Table_Internal<TFeatures, TData>
-    return tableMemo({
-      feature: 'columnFacetingFeature',
-      fn: (flatRows) => _createFacetedMinMaxValues(table, columnId, flatRows),
-      fnName: 'table.getFacetedMinMaxValues',
-      memoDeps: () => {
-        if (columnId === '__global__') {
-          return [
-            callMemoOrStaticFn(
-              table,
-              'getGlobalFacetedRowModel',
-              table_getGlobalFacetedRowModel,
-            ).flatRows,
-          ]
-        }
-        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,
->(
-  table: Table_Internal<TFeatures, TData>,
-  columnId: string,
-  flatRows: Array<Row<TFeatures, TData>>,
-): undefined | [number, number] {
-  if (!flatRows.length) return undefined
-
-  // The global context aggregates values across every column that
-  // participates in global filtering
-  const columnIds =
-    columnId === '__global__'
-      ? table
-          .getAllLeafColumns()
-          .filter((column) => column_getCanGlobalFilter(column))
-          .map((column) => column.id)
-      : [columnId]
-
-  let facetedMinValue = Number.POSITIVE_INFINITY
-  let facetedMaxValue = Number.NEGATIVE_INFINITY
-  let foundAny = false
-
-  for (let i = 0; i < flatRows.length; i++) {
-    for (let c = 0; c < columnIds.length; c++) {
-      const value = Number(flatRows[i]!.getValue(columnIds[c]!))
-      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

@@ -1,92 +0,0 @@
-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 as unknown as Table_Internal<TFeatures, TData>
-    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)
-    }
-  }
-  // The global context excludes the global filter itself, mirroring how a
-  // column's faceted model excludes that column's own filter
-  if (globalFilter && columnId !== '__global__')
-    filterableIds.push('__global__')
-
-  if (!filterableIds.length) {
-    return preRowModel
-  }
-
-  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

@@ -1,97 +0,0 @@
-import { callMemoOrStaticFn, tableMemo } from '../../utils'
-import { column_getCanGlobalFilter } from '../global-filtering/globalFilteringFeature.utils'
-import {
-  column_getFacetedRowModel,
-  table_getGlobalFacetedRowModel,
-} 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 as unknown as Table_Internal<TFeatures, TData>
-    return tableMemo({
-      feature: 'columnFacetingFeature',
-      table,
-      fnName: 'table.getFacetedUniqueValues',
-      memoDeps: () => {
-        if (columnId === '__global__') {
-          return [
-            callMemoOrStaticFn(
-              table,
-              'getGlobalFacetedRowModel',
-              table_getGlobalFacetedRowModel,
-            ).flatRows,
-          ]
-        }
-        const column = table.getColumn(columnId)
-        if (!column) return [table.getPreFilteredRowModel().flatRows]
-        return [
-          callMemoOrStaticFn(
-            column,
-            'getFacetedRowModel',
-            column_getFacetedRowModel,
-            table,
-          ).flatRows,
-        ]
-      },
-      fn: (flatRows) => _createFacetedUniqueValues(table, columnId, flatRows),
-    })
-  }
-}
-
-function _createFacetedUniqueValues<
-  TFeatures extends TableFeatures,
-  TData extends RowData = any,
->(
-  table: Table_Internal<TFeatures, TData>,
-  columnId: string,
-  flatRows: Array<Row<TFeatures, TData>>,
-): Map<any, number> {
-  // The global context aggregates unique values across every column that
-  // participates in global filtering
-  const columnIds =
-    columnId === '__global__'
-      ? table
-          .getAllLeafColumns()
-          .filter((column) => column_getCanGlobalFilter(column))
-          .map((column) => column.id)
-      : [columnId]
-
-  const facetedUniqueValues = new Map<any, number>()
-
-  for (let i = 0; i < flatRows.length; i++) {
-    for (let c = 0; c < columnIds.length; c++) {
-      // the declared return type is Array, but rows return undefined for
-      // columns without an accessor (e.g. display columns)
-      const values = flatRows[i]!.getUniqueValues(columnIds[c]!) as
-        | Array<unknown>
-        | undefined
-      if (!values) continue
-
-      for (let j = 0; j < values.length; j++) {
-        const value = values[j]
-        const previousValue = facetedUniqueValues.get(value)
-        facetedUniqueValues.set(
-          value,
-          previousValue === undefined ? 1 : previousValue + 1,
-        )
-      }
-    }
-  }
-
-  return facetedUniqueValues
-}

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

@@ -1,87 +0,0 @@
-import {
-  assignPrototypeAPIs,
-  assignTableAPIs,
-  makeObjectMap,
-  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 { TableFeature } from '../../types/TableFeatures'
-
-/**
- * Feature that adds per-column filtering state, options, and column/table filter APIs.
- */
-export const columnFilteringFeature: TableFeature = {
-  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 = makeObjectMap()
-    ;(row as any).columnFiltersMeta = makeObjectMap()
-  },
-
-  constructTableAPIs: (table) => {
-    assignTableAPIs('columnFilteringFeature', table, {
-      table_setColumnFilters: {
-        fn: (updater) => table_setColumnFilters(table, updater),
-      },
-      table_resetColumnFilters: {
-        fn: (defaultState) => table_resetColumnFilters(table, defaultState),
-      },
-    })
-  },
-}