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

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

@@ -0,0 +1,183 @@
+import { tableMemo } from '../../utils'
+import { table_getColumn } from '../../core/columns/coreColumnsFeature.utils'
+import {
+  column_getCanGlobalFilter,
+  table_getGlobalFilterFn,
+} from '../global-filtering/globalFilteringFeature.utils'
+import { table_autoResetPageIndex } from '../row-pagination/rowPaginationFeature.utils'
+import { filterRows } from './filterRowsUtils'
+import { column_getFilterFn } from './columnFilteringFeature.utils'
+import type { RowData } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
+import type { Table, Table_Internal } from '../../types/Table'
+import type { Row } from '../../types/Row'
+import type {
+  FilterFn,
+  FilterFns,
+  ResolvedColumnFilter,
+  Row_ColumnFiltering,
+} from './columnFilteringFeature.types'
+
+/**
+ * Creates a memoized filtered 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 createFilteredRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+>(
+  filterFns: Record<keyof FilterFns, FilterFn<TFeatures, TData>>,
+): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {
+  return (_table) => {
+    const table: Table_Internal<TFeatures, TData> = _table
+    if (!table._rowModelFns.filterFns) table._rowModelFns.filterFns = filterFns
+    return tableMemo({
+      feature: 'columnFilteringFeature',
+      table,
+      fnName: 'table.getFilteredRowModel',
+      memoDeps: () => [
+        table.getPreFilteredRowModel(),
+        table.atoms.columnFilters?.get(),
+        table.atoms.globalFilter?.get(),
+      ],
+      fn: () => _createFilteredRowModel(table),
+      onAfterUpdate: () => table_autoResetPageIndex(table),
+    })
+  }
+}
+
+function _createFilteredRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  const rowModel = table.getPreFilteredRowModel()
+  const columnFilters = table.atoms.columnFilters?.get()
+  const globalFilter = table.atoms.globalFilter?.get()
+
+  if (!rowModel.rows.length || (!columnFilters?.length && !globalFilter)) {
+    const flatRows = rowModel.flatRows as Array<
+      Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>
+    >
+    for (let i = 0; i < flatRows.length; i++) {
+      const row = flatRows[i]!
+      row.columnFilters = {}
+      row.columnFiltersMeta = {}
+    }
+    return rowModel
+  }
+
+  const resolvedColumnFilters: Array<ResolvedColumnFilter<TFeatures, TData>> =
+    []
+  const resolvedGlobalFilters: Array<ResolvedColumnFilter<TFeatures, TData>> =
+    []
+
+  columnFilters?.forEach((columnFilter) => {
+    const column = table_getColumn(table, columnFilter.id)
+
+    if (!column) {
+      return
+    }
+
+    const filterFn = column_getFilterFn(column)!
+
+    resolvedColumnFilters.push({
+      id: columnFilter.id,
+      filterFn,
+      resolvedValue:
+        filterFn.resolveFilterValue?.(columnFilter.value) ?? columnFilter.value,
+    })
+  })
+
+  const filterableIds = columnFilters?.map((d) => d.id) ?? []
+
+  const globalFilterFn = table_getGlobalFilterFn(table)
+
+  const globallyFilterableColumns = table
+    .getAllLeafColumns()
+    .filter((column) => column_getCanGlobalFilter(column))
+
+  if (globalFilter && globalFilterFn && globallyFilterableColumns.length) {
+    filterableIds.push('__global__')
+
+    globallyFilterableColumns.forEach((column) => {
+      resolvedGlobalFilters.push({
+        id: column.id,
+        filterFn: globalFilterFn,
+        resolvedValue:
+          globalFilterFn.resolveFilterValue?.(globalFilter) ?? globalFilter,
+      })
+    })
+  }
+
+  // Flag the pre-filtered row model with each filter state
+  const flatRows = rowModel.flatRows as Array<
+    Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>
+  >
+  for (let i = 0; i < flatRows.length; i++) {
+    const row = flatRows[i]!
+    row.columnFilters = {}
+
+    if (resolvedColumnFilters.length) {
+      for (let j = 0; j < resolvedColumnFilters.length; j++) {
+        const currentColumnFilter = resolvedColumnFilters[j]!
+        const id = currentColumnFilter.id
+
+        // Tag the row with the column filter state
+        row.columnFilters[id] = currentColumnFilter.filterFn(
+          row,
+          id,
+          currentColumnFilter.resolvedValue,
+          (filterMeta) => {
+            !row.columnFiltersMeta
+              ? (row.columnFiltersMeta = {})
+              : (row.columnFiltersMeta[id] = filterMeta)
+          },
+        )
+      }
+    }
+
+    if (resolvedGlobalFilters.length) {
+      for (let j = 0; j < resolvedGlobalFilters.length; j++) {
+        const currentGlobalFilter = resolvedGlobalFilters[j]!
+        const id = currentGlobalFilter.id
+        // Tag the row with the first truthy global filter state
+        if (
+          currentGlobalFilter.filterFn(
+            row,
+            id,
+            currentGlobalFilter.resolvedValue,
+            (filterMeta) => {
+              !row.columnFiltersMeta
+                ? (row.columnFiltersMeta = {})
+                : (row.columnFiltersMeta[id] = filterMeta)
+            },
+          )
+        ) {
+          row.columnFilters.__global__ = true
+          break
+        }
+      }
+
+      if (row.columnFilters.__global__ !== true) {
+        row.columnFilters.__global__ = false
+      }
+    }
+  }
+
+  const filterRowsImpl = (
+    row: Row<TFeatures, TData> & 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
+  }
+
+  // Filter final rows using all of the active filters
+  return filterRows(rowModel.rows, filterRowsImpl as any, table)
+}

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

@@ -0,0 +1,157 @@
+import { constructRow } from '../../core/rows/constructRow'
+import type { Row_ColumnFiltering } from './columnFilteringFeature.types'
+import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
+import type { Row } from '../../types/Row'
+import type { Table_Internal } from '../../types/Table'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { RowData } from '../../types/type-utils'
+
+/**
+ * Filters a row model with the supplied row predicate.
+ *
+ * The helper supports both filtering from leaf rows upward and filtering parents before descendants, depending on table options.
+ */
+export function filterRows<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  rows: Array<Row<TFeatures, TData>>,
+  filterRowImpl: (row: Row<TFeatures, TData>) => any,
+  table: Table_Internal<TFeatures, TData>,
+) {
+  if (table.options.filterFromLeafRows) {
+    return filterRowModelFromLeafs(rows, filterRowImpl, table)
+  }
+
+  return filterRowModelFromRoot(rows, filterRowImpl, table)
+}
+
+function filterRowModelFromLeafs<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  rowsToFilter: Array<Row<TFeatures, TData>>,
+  filterRow: (
+    row: Row<TFeatures, TData>,
+  ) => Array<Row<TFeatures, TData>> | undefined,
+  table: Table_Internal<TFeatures, TData>,
+): RowModel<TFeatures, TData> {
+  const newFilteredFlatRows: Array<Row<TFeatures, TData>> = []
+  const newFilteredRowsById: Record<string, Row<TFeatures, TData>> = {}
+  const maxDepth = table.options.maxLeafRowFilterDepth ?? 100
+
+  const recurseFilterRows = (
+    rowsToFilter: Array<
+      Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>
+    >,
+    depth = 0,
+  ) => {
+    const filteredRows: Array<Row<TFeatures, TData>> &
+      Partial<Row_ColumnFiltering<TFeatures, TData>> = []
+
+    // Filter from children up first
+    for (let row of rowsToFilter) {
+      const newRow = constructRow(
+        table,
+        row.id,
+        row.original,
+        row.index,
+        row.depth,
+        undefined,
+        row.parentId,
+      ) as Row<TFeatures, TData> &
+        Partial<Row_ColumnFiltering<TFeatures, TData>>
+      newRow.columnFilters = row.columnFilters
+
+      if (row.subRows.length && depth < maxDepth) {
+        newRow.subRows = recurseFilterRows(row.subRows, depth + 1)
+        row = newRow
+
+        if (filterRow(row) && !newRow.subRows.length) {
+          filteredRows.push(row)
+          newFilteredRowsById[row.id] = row
+          newFilteredFlatRows.push(row)
+          continue
+        }
+
+        if (filterRow(row) || newRow.subRows.length) {
+          filteredRows.push(row)
+          newFilteredRowsById[row.id] = row
+          newFilteredFlatRows.push(row)
+          continue
+        }
+      } else {
+        row = newRow
+        if (filterRow(row)) {
+          filteredRows.push(row)
+          newFilteredRowsById[row.id] = row
+          newFilteredFlatRows.push(row)
+        }
+      }
+    }
+
+    return filteredRows
+  }
+
+  return {
+    rows: recurseFilterRows(rowsToFilter),
+    flatRows: newFilteredFlatRows,
+    rowsById: newFilteredRowsById,
+  }
+}
+
+function filterRowModelFromRoot<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  rowsToFilter: Array<Row<TFeatures, TData>>,
+  filterRow: (row: Row<TFeatures, TData>) => any,
+  table: Table_Internal<TFeatures, TData>,
+): RowModel<TFeatures, TData> {
+  const newFilteredFlatRows: Array<Row<TFeatures, TData>> = []
+  const newFilteredRowsById: Record<string, Row<TFeatures, TData>> = {}
+  const maxDepth = table.options.maxLeafRowFilterDepth ?? 100
+
+  // Filters top level and nested rows
+  const recurseFilterRows = (
+    rowsToFilter: Array<Row<TFeatures, TData>>,
+    depth = 0,
+  ) => {
+    // Filter from parents downward first
+
+    const filteredRows: Array<Row<TFeatures, TData>> = []
+
+    // Apply the filter to any subRows
+    for (let row of rowsToFilter) {
+      const pass = filterRow(row)
+
+      if (pass) {
+        if (row.subRows.length && depth < maxDepth) {
+          const newRow = constructRow(
+            table,
+            row.id,
+            row.original,
+            row.index,
+            row.depth,
+            undefined,
+            row.parentId,
+          )
+          newRow.subRows = recurseFilterRows(row.subRows, depth + 1)
+          row = newRow
+        }
+
+        filteredRows.push(row)
+        newFilteredFlatRows.push(row)
+        newFilteredRowsById[row.id] = row
+      }
+    }
+
+    return filteredRows
+  }
+
+  return {
+    rows: recurseFilterRows(rowsToFilter),
+    flatRows: newFilteredFlatRows,
+    rowsById: newFilteredRowsById,
+  }
+}

package/src/features/column-grouping/columnGroupingFeature.ts

@@ -0,0 +1,159 @@
+import {
+  assignPrototypeAPIs,
+  assignTableAPIs,
+  makeStateUpdater,
+} from '../../utils'
+import {
+  cell_getIsAggregated,
+  cell_getIsGrouped,
+  cell_getIsPlaceholder,
+  column_getAggregationFn,
+  column_getAutoAggregationFn,
+  column_getCanGroup,
+  column_getGroupedIndex,
+  column_getIsGrouped,
+  column_getToggleGroupingHandler,
+  column_toggleGrouping,
+  getDefaultGroupingState,
+  row_getGroupingValue,
+  row_getIsGrouped,
+  table_resetGrouping,
+  table_setGrouping,
+} from './columnGroupingFeature.utils'
+import type { RowData } from '../../types/type-utils'
+import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
+// import type {
+//   CachedRowModel_Grouped,
+//   Cell_ColumnGrouping,
+//   ColumnDef_ColumnGrouping,
+//   Column_ColumnGrouping,
+//   CreateRowModel_Grouped,
+//   RowModelFns_ColumnGrouping,
+//   Row_ColumnGrouping,
+//   TableOptions_ColumnGrouping,
+//   TableState_ColumnGrouping,
+//   Table_ColumnGrouping,
+// } from './columnGroupingFeature.types'
+
+export interface ColumnGroupingFeatureConstructors<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  // CachedRowModel: CachedRowModel_Grouped<TFeatures, TData>
+  // Cell: Cell_ColumnGrouping
+  // Column: Column_ColumnGrouping<TFeatures, TData>
+  // ColumnDef: ColumnDef_ColumnGrouping<TFeatures, TData>
+  // CreateRowModels: CreateRowModel_Grouped<TFeatures, TData>
+  // Row: Row_ColumnGrouping
+  // RowModelFns: RowModelFns_ColumnGrouping<TFeatures, TData>
+  // Table: Table_ColumnGrouping<TFeatures, TData>
+  // TableOptions: TableOptions_ColumnGrouping
+  // TableState: TableState_ColumnGrouping
+}
+
+/**
+ * Creates the stock column grouping feature.
+ *
+ * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ */
+export function constructColumnGroupingFeature<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(): TableFeature<ColumnGroupingFeatureConstructors<TFeatures, TData>> {
+  return {
+    getInitialState: (initialState) => {
+      return {
+        grouping: getDefaultGroupingState(),
+        ...initialState,
+      }
+    },
+
+    getDefaultColumnDef: () => {
+      return {
+        aggregatedCell: ({ getValue }: any) => getValue()?.toString?.() ?? null,
+        aggregationFn: 'auto',
+      }
+    },
+
+    getDefaultTableOptions: (table) => {
+      return {
+        onGroupingChange: makeStateUpdater('grouping', table),
+        groupedColumnMode: 'reorder',
+      }
+    },
+
+    assignCellPrototype: (prototype, table) => {
+      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
+        cell_getIsGrouped: {
+          fn: (cell) => cell_getIsGrouped(cell),
+        },
+        cell_getIsPlaceholder: {
+          fn: (cell) => cell_getIsPlaceholder(cell),
+        },
+        cell_getIsAggregated: {
+          fn: (cell) => cell_getIsAggregated(cell),
+        },
+      })
+    },
+
+    assignColumnPrototype: (prototype, table) => {
+      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
+        column_toggleGrouping: {
+          fn: (column) => column_toggleGrouping(column),
+        },
+        column_getCanGroup: {
+          fn: (column) => column_getCanGroup(column),
+        },
+        column_getIsGrouped: {
+          fn: (column) => column_getIsGrouped(column),
+        },
+        column_getGroupedIndex: {
+          fn: (column) => column_getGroupedIndex(column),
+        },
+        column_getToggleGroupingHandler: {
+          fn: (column) => column_getToggleGroupingHandler(column),
+        },
+        column_getAutoAggregationFn: {
+          fn: (column) => column_getAutoAggregationFn(column),
+        },
+        column_getAggregationFn: {
+          fn: (column) => column_getAggregationFn(column),
+        },
+      })
+    },
+
+    assignRowPrototype: (prototype, table) => {
+      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
+        row_getIsGrouped: {
+          fn: (row) => row_getIsGrouped(row),
+        },
+        row_getGroupingValue: {
+          fn: (row, columnId) => row_getGroupingValue(row, columnId),
+        },
+      })
+    },
+
+    initRowInstanceData: (row) => {
+      ;(row as any)._groupingValuesCache = {}
+    },
+
+    constructTableAPIs: (table) => {
+      assignTableAPIs('columnGroupingFeature', table, {
+        table_setGrouping: {
+          fn: (updater) => table_setGrouping(table, updater),
+        },
+        table_resetGrouping: {
+          fn: (defaultState) => table_resetGrouping(table, defaultState),
+        },
+      })
+    },
+  }
+}
+
+/**
+ * The stock column grouping feature.
+ *
+ * Register this feature to add grouping state, aggregation defaults, grouped
+ * row-model support, and table/row/column/cell grouping APIs.
+ */
+export const columnGroupingFeature = constructColumnGroupingFeature()