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

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

@@ -1,258 +0,0 @@
-import { hasOwn, makeObjectMap, tableMemo } from '../../utils'
-import { constructRow } from '../../core/rows/constructRow'
-import { table_getColumn } from '../../core/columns/coreColumnsFeature.utils'
-import { table_autoResetExpanded } from '../row-expanding/rowExpandingFeature.utils'
-import { table_autoResetPageIndex } from '../row-pagination/rowPaginationFeature.utils'
-import {
-  aggregateColumnValue,
-  normalizeUniqueAggregationRows,
-} from '../row-aggregation/rowAggregationFeature.utils'
-import type { Row_ColumnGrouping } from './columnGroupingFeature.types'
-import type { Column_Internal } from '../../types/Column'
-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 { RowData } from '../../types/type-utils'
-
-/**
- * Creates a memoized grouped 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.
- *
- * When rowAggregationFeature is also registered, grouped rows use its shared
- * executor for non-group values. Grouping remains useful without aggregation.
- */
-export function createGroupedRowModel<
-  TFeatures extends TableFeatures,
-  TData extends RowData = any,
->(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {
-  return (_table) => {
-    const table = _table as unknown as Table_Internal<TFeatures, TData>
-    return tableMemo({
-      feature: 'columnGroupingFeature',
-      table,
-      fnName: 'table.getGroupedRowModel',
-      memoDeps: () => [
-        table.atoms.grouping?.get(),
-        table.getPreGroupedRowModel(),
-        table.options.columns,
-      ],
-      fn: () => _createGroupedRowModel(table),
-      onAfterUpdate: () => {
-        table_autoResetExpanded(table)
-        table_autoResetPageIndex(table)
-      },
-    })
-  }
-}
-
-function _createGroupedRowModel<
-  TFeatures extends TableFeatures,
-  TData extends RowData = any,
->(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  const rowModel = table.getPreGroupedRowModel()
-  const grouping = table.atoms.grouping?.get()
-
-  if (!rowModel.rows.length || !grouping?.length) {
-    rowModel.rows.forEach((row) => {
-      row.depth = 0
-      row.parentId = undefined
-    })
-    return rowModel
-  }
-
-  // Filter the grouping list down to columns that exist
-  const existingGrouping = grouping.filter((columnId) =>
-    table_getColumn(table, columnId),
-  )
-
-  const groupedFlatRows: Array<Row<TFeatures, TData>> &
-    Partial<Row_ColumnGrouping> = []
-  const groupedRowsById = makeObjectMap<Row<TFeatures, TData>>()
-
-  // Recursively group the data
-  const groupUpRecursively = (
-    rows: Array<Row<TFeatures, TData>>,
-    depth = 0,
-    parentId?: string,
-  ) => {
-    // Grouping depth has been been met
-    // Stop grouping and simply rewrite thd depth and row relationships
-    if (depth >= existingGrouping.length) {
-      return rows.map((row) => {
-        row.depth = depth
-
-        // Every row is pushed into flatRows/rowsById exactly once, by its
-        // parent frame: rows returned here are pushed by the caller (the
-        // parent group's loop or the root loop), so only descendants below
-        // the terminal depth are pushed here.
-        if (row.subRows.length) {
-          row.subRows = groupUpRecursively(row.subRows, depth + 1, row.id)
-          for (let i = 0; i < row.subRows.length; i++) {
-            const subRow = row.subRows[i]!
-            groupedFlatRows.push(subRow)
-            groupedRowsById[subRow.id] = subRow
-          }
-        }
-
-        return row
-      })
-    }
-
-    const columnId = existingGrouping[depth] as string
-
-    // Group the rows together for this level
-    const rowGroupsMap = groupBy(table, rows, columnId)
-
-    // Perform aggregations for each group
-    const aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map(
-      ([groupingValue, groupedRows], index) => {
-        let id = `${columnId}:${groupingValue}`
-        id = parentId ? `${parentId}>${id}` : id
-
-        // First, Recurse to group sub rows before aggregation
-        const subRows = groupUpRecursively(groupedRows, depth + 1, id)
-
-        subRows.forEach((subRow) => {
-          subRow.parentId = id
-        })
-
-        // Rows produced by groupBy are disjoint members of the pre-grouped
-        // row tree, so the duplicate-id guard is unnecessary; flat groups
-        // reuse the partition array as-is.
-        const leafRows = normalizeUniqueAggregationRows(
-          groupedRows,
-          Infinity,
-        ) as Array<Row<TFeatures, TData>>
-
-        const row = constructRow(
-          table,
-          id,
-          leafRows[0]!.original,
-          index,
-          depth,
-          undefined,
-          parentId,
-        ) as Row<TFeatures, TData> & Partial<Row_ColumnGrouping>
-
-        Object.assign(row, {
-          groupingColumnId: columnId,
-          groupingValue,
-          subRows,
-          leafRows,
-          getValue: (colId: string) => {
-            const groupingIndex = existingGrouping.indexOf(colId)
-
-            // The active grouping column and ancestor grouping columns expose
-            // their inherited grouping values. Columns grouped at deeper
-            // levels are still eligible for aggregation here.
-            if (groupingIndex !== -1 && groupingIndex <= depth) {
-              if (hasOwn(row._valuesCache, colId)) {
-                return row._valuesCache[colId]
-              }
-
-              if (groupedRows[0]) {
-                row._valuesCache[colId] =
-                  groupedRows[0].getValue(colId) ?? undefined
-              }
-
-              return row._valuesCache[colId]
-            }
-
-            const aggregationCache = (row as any)._aggregationValuesCache as
-              | Record<string, unknown>
-              | undefined
-            if (aggregationCache && hasOwn(aggregationCache, colId)) {
-              return aggregationCache[colId]
-            }
-
-            const column = table.getColumn(colId) as any
-            if (typeof column.getAggregationFns !== 'function') return undefined
-
-            const cache = ((row as any)._aggregationValuesCache ??=
-              makeObjectMap())
-            cache[colId] = aggregateColumnValue({
-              subRows,
-              column,
-              groupingRow: row,
-              rows: groupedRows,
-              uniqueRows: true,
-            })
-            return cache[colId]
-          },
-        })
-
-        subRows.forEach((subRow) => {
-          groupedFlatRows.push(subRow)
-          groupedRowsById[subRow.id] = subRow
-        })
-
-        return row
-      },
-    )
-
-    return aggregatedGroupedRows
-  }
-
-  const groupedRows = groupUpRecursively(rowModel.rows, 0)
-
-  groupedRows.forEach((subRow) => {
-    groupedFlatRows.push(subRow)
-    groupedRowsById[subRow.id] = subRow
-  })
-
-  return {
-    rows: groupedRows,
-    flatRows: groupedFlatRows,
-    rowsById: groupedRowsById,
-  }
-}
-
-function groupBy<TFeatures extends TableFeatures, TData extends RowData = any>(
-  table: Table_Internal<TFeatures, TData>,
-  rows: Array<Row<TFeatures, TData>>,
-  columnId: string,
-) {
-  const groupMap = new Map<any, Array<Row<TFeatures, TData>>>()
-
-  // Resolve the column once instead of per row: `table.getColumn` goes
-  // through the memoized-API dispatcher, which is far too expensive to sit
-  // inside this per-row loop. The branches below mirror
-  // `row_getGroupingValue`'s caching contract exactly.
-  const column = table_getColumn(table, columnId) as
-    | Column_Internal<TFeatures, TData, unknown>
-    | undefined
-  const getGroupingValue = column?.columnDef.getGroupingValue
-
-  for (let i = 0; i < rows.length; i++) {
-    const row = rows[i]!
-    let groupingValue
-    if (getGroupingValue) {
-      const cache = (row as any)._groupingValuesCache as
-        | Record<string, unknown>
-        | undefined
-      if (cache && hasOwn(cache, columnId)) {
-        groupingValue = cache[columnId]
-      } else if (cache) {
-        groupingValue = cache[columnId] = getGroupingValue(
-          row.original,
-          row.index,
-          row,
-        )
-      }
-    } else {
-      groupingValue = row.getValue(columnId)
-    }
-
-    const resKey = `${groupingValue}`
-    const previous = groupMap.get(resKey)
-    if (!previous) {
-      groupMap.set(resKey, [row])
-    } else {
-      previous.push(row)
-    }
-  }
-
-  return groupMap
-}

package/src/features/column-ordering/columnOrderingFeature.ts

@@ -1,78 +0,0 @@
-import {
-  assignPrototypeAPIs,
-  assignTableAPIs,
-  makeStateUpdater,
-} from '../../utils'
-import {
-  column_getIndex,
-  column_getIsFirstColumn,
-  column_getIsLastColumn,
-  getDefaultColumnOrderState,
-  table_getColumnIndexes,
-  table_getOrderColumnsFn,
-  table_resetColumnOrder,
-  table_setColumnOrder,
-} from './columnOrderingFeature.utils'
-import type { TableFeature } from '../../types/TableFeatures'
-
-/**
- * Feature that adds column ordering state and APIs for ordering leaf columns.
- */
-export const columnOrderingFeature: TableFeature = {
-  getInitialState: (initialState) => {
-    return {
-      columnOrder: getDefaultColumnOrderState(),
-      ...initialState,
-    }
-  },
-
-  getDefaultTableOptions: (table) => {
-    return {
-      onColumnOrderChange: makeStateUpdater('columnOrder', table),
-    }
-  },
-
-  assignColumnPrototype: (prototype, table) => {
-    assignPrototypeAPIs('columnOrderingFeature', prototype, table, {
-      column_getIndex: {
-        fn: (column, position) => column_getIndex(column, position),
-      },
-      column_getIsFirstColumn: {
-        fn: (column, position) => column_getIsFirstColumn(column, position),
-      },
-      column_getIsLastColumn: {
-        fn: (column, position) => column_getIsLastColumn(column, position),
-      },
-    })
-  },
-
-  constructTableAPIs: (table) => {
-    assignTableAPIs('columnOrderingFeature', table, {
-      table_getColumnIndexes: {
-        fn: () => table_getColumnIndexes(table),
-        memoDeps: () => [
-          table.options.columns,
-          table.atoms.columnOrder?.get(),
-          table.atoms.columnPinning?.get(),
-          table.atoms.columnVisibility?.get(),
-          table.atoms.grouping?.get(),
-          table.options.groupedColumnMode,
-        ],
-      },
-      table_setColumnOrder: {
-        fn: (updater) => table_setColumnOrder(table, updater),
-      },
-      table_resetColumnOrder: {
-        fn: (defaultState) => table_resetColumnOrder(table, defaultState),
-      },
-      table_getOrderColumnsFn: {
-        fn: () => table_getOrderColumnsFn(table),
-        memoDeps: () => [
-          table.atoms.columnOrder?.get(),
-          table.atoms.grouping?.get(),
-          table.options.groupedColumnMode,
-        ],
-      },
-    })
-  },
-}

package/src/features/column-ordering/columnOrderingFeature.types.ts

@@ -1,86 +0,0 @@
-import type { OnChangeFn, RowData, Updater } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
-import type { ColumnPinningPosition } from '../column-pinning/columnPinningFeature.types'
-
-export type ColumnOrderState = Array<string>
-
-export interface ColumnIndexes {
-  /**
-   * Maps each visible leaf column id to its index in the full visible column list.
-   */
-  all: Record<string, number>
-  /**
-   * Maps each unpinned visible leaf column id to its index within the center region.
-   */
-  center: Record<string, number>
-  /**
-   * Maps each start-pinned visible leaf column id to its index within the start region.
-   */
-  start: Record<string, number>
-  /**
-   * Maps each end-pinned visible leaf column id to its index within the end region.
-   */
-  end: Record<string, number>
-}
-
-export interface TableState_ColumnOrdering {
-  columnOrder: ColumnOrderState
-}
-
-export interface TableOptions_ColumnOrdering {
-  /**
-   * Called with an updater when column order state changes. Pair this with
-   * `state.columnOrder` when using external state; external atoms can own the
-   * slice without this callback.
-   */
-  onColumnOrderChange?: OnChangeFn<ColumnOrderState>
-}
-
-export interface Column_ColumnOrdering {
-  /**
-   * Finds this column's zero-based index among visible columns.
-   *
-   * Pass `'start'`, `'center'`, or `'end'` to measure within that pinned
-   * region instead of the full visible leaf order.
-   */
-  getIndex: (position?: ColumnPinningPosition | 'center') => number
-  /**
-   * Checks whether this column is the first visible column.
-   *
-   * Pass a pinned region to check the first column within that region.
-   */
-  getIsFirstColumn: (position?: ColumnPinningPosition | 'center') => boolean
-  /**
-   * Checks whether this column is the last visible column.
-   *
-   * Pass a pinned region to check the last column within that region.
-   */
-  getIsLastColumn: (position?: ColumnPinningPosition | 'center') => boolean
-}
-
-export interface ColumnOrderDefaultOptions {
-  onColumnOrderChange: OnChangeFn<ColumnOrderState>
-}
-
-export interface Table_ColumnOrdering<
-  in out _TFeatures extends TableFeatures,
-  in out _TData extends RowData,
-> {
-  /**
-   * Builds column-id to index records for each visible pinning region.
-   *
-   * This is the memoized source that `column.getIndex` reads from; most apps
-   * will not need to call it directly.
-   */
-  getColumnIndexes: () => ColumnIndexes
-  /**
-   * Resets `columnOrder` to `initialState.columnOrder`.
-   *
-   * Pass `true` to ignore initial state and reset to `[]`.
-   */
-  resetColumnOrder: (defaultState?: boolean) => void
-  /**
-   * Updates column order state with a next ordered id array or updater function.
-   */
-  setColumnOrder: (updater: Updater<ColumnOrderState>) => void
-}