@tanstack/table-core 9.0.0-alpha.10 → 9.0.0-alpha.11

package/src/features/row-pinning/rowPinningFeature.utils.ts

@@ -0,0 +1,197 @@
+import { row_getIsAllParentsExpanded } from '../row-expanding/rowExpandingFeature.utils'
+import { callMemoOrStaticFn } from '../../utils'
+import type { RowData, Updater } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { Table_Internal } from '../../types/Table'
+import type { Row } from '../../types/Row'
+import type {
+  RowPinningPosition,
+  RowPinningState,
+} from './rowPinningFeature.types'
+
+// State Utils
+
+export function getDefaultRowPinningState(): RowPinningState {
+  return structuredClone({
+    top: [],
+    bottom: [],
+  })
+}
+
+export function table_setRowPinning<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  table: Table_Internal<TFeatures, TData>,
+  updater: Updater<RowPinningState>,
+): void {
+  table.options.onRowPinningChange?.(updater)
+}
+
+export function table_resetRowPinning<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void {
+  table_setRowPinning(
+    table,
+    defaultState
+      ? getDefaultRowPinningState()
+      : (table.initialState.rowPinning ?? getDefaultRowPinningState()),
+  )
+}
+
+// Table Utils
+
+export function table_getIsSomeRowsPinned<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  table: Table_Internal<TFeatures, TData>,
+  position?: RowPinningPosition,
+): boolean {
+  const rowPinning = table.store.state.rowPinning
+
+  if (!position) {
+    return Boolean(rowPinning?.top.length || rowPinning?.bottom.length)
+  }
+  return Boolean(rowPinning?.[position].length)
+}
+
+function table_getPinnedRows<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  table: Table_Internal<TFeatures, TData>,
+  position: 'top' | 'bottom',
+): Array<Row<TFeatures, TData>> {
+  const visibleRows = table.getRowModel().rows
+  const pinnedRowIds = table.store.state.rowPinning?.[position] ?? []
+
+  const rows =
+    (table.options.keepPinnedRows ?? true)
+      ? // get all rows that are pinned even if they would not be otherwise visible
+        // account for expanded parent rows, but not pagination or filtering
+        pinnedRowIds.map((rowId) => {
+          const row = table.getRow(rowId, true)
+          return row_getIsAllParentsExpanded(row) ? row : null
+        })
+      : // else get only visible rows that are pinned
+        pinnedRowIds.map(
+          (rowId) => visibleRows.find((row) => row.id === rowId)!,
+        )
+
+  const filteredRows = rows.filter((r) => !!r)
+  // Assign position property directly to preserve prototype chain
+  filteredRows.forEach((row) => {
+    ;(row as any).position = position
+  })
+  return filteredRows
+}
+
+export function table_getTopRows<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): Array<Row<TFeatures, TData>> {
+  return table_getPinnedRows(table, 'top')
+}
+
+export function table_getBottomRows<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): Array<Row<TFeatures, TData>> {
+  return table_getPinnedRows(table, 'bottom')
+}
+
+export function table_getCenterRows<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): Array<Row<TFeatures, TData>> {
+  const { top, bottom } =
+    table.store.state.rowPinning ?? getDefaultRowPinningState()
+  const allRows = table.getRowModel().rows
+
+  const topAndBottom = new Set([...top, ...bottom])
+  return allRows.filter((d) => !topAndBottom.has(d.id))
+}
+
+// Row Utils
+
+export function row_getCanPin<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(row: Row<TFeatures, TData>): boolean {
+  const { enableRowPinning } = row.table.options
+  if (typeof enableRowPinning === 'function') {
+    return enableRowPinning(row)
+  }
+  return enableRowPinning ?? true
+}
+
+export function row_getIsPinned<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(row: Row<TFeatures, TData>): RowPinningPosition {
+  const { top, bottom } =
+    row.table.store.state.rowPinning ?? getDefaultRowPinningState()
+
+  return top.includes(row.id)
+    ? 'top'
+    : bottom.includes(row.id)
+      ? 'bottom'
+      : false
+}
+
+export function row_getPinnedIndex<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(row: Row<TFeatures, TData>): number {
+  const position = row_getIsPinned(row)
+  if (!position) return -1
+
+  const visiblePinnedRowIds = (
+    position === 'top'
+      ? callMemoOrStaticFn(row.table, 'getTopRows', table_getTopRows)
+      : callMemoOrStaticFn(row.table, 'getBottomRows', table_getBottomRows)
+  ).map(({ id }) => id)
+
+  return visiblePinnedRowIds.indexOf(row.id)
+}
+
+export function row_pin<TFeatures extends TableFeatures, TData extends RowData>(
+  row: Row<TFeatures, TData>,
+  position: RowPinningPosition,
+  includeLeafRows?: boolean,
+  includeParentRows?: boolean,
+): void {
+  const leafRowIds = includeLeafRows
+    ? row.getLeafRows().map(({ id }) => id)
+    : []
+  const parentRowIds = includeParentRows
+    ? row.getParentRows().map(({ id }) => id)
+    : []
+  const rowIds: Set<string> = new Set([...parentRowIds, row.id, ...leafRowIds])
+
+  table_setRowPinning(row.table, (old) => {
+    if (position === 'bottom') {
+      return {
+        top: old.top.filter((d) => !rowIds.has(d)),
+        bottom: [
+          ...old.bottom.filter((d) => !rowIds.has(d)),
+          ...Array.from(rowIds),
+        ],
+      }
+    }
+
+    if (position === 'top') {
+      return {
+        top: [...old.top.filter((d) => !rowIds.has(d)), ...Array.from(rowIds)],
+        bottom: old.bottom.filter((d) => !rowIds.has(d)),
+      }
+    }
+
+    return {
+      top: old.top.filter((d) => !rowIds.has(d)),
+      bottom: old.bottom.filter((d) => !rowIds.has(d)),
+    }
+  })
+}

package/src/features/row-selection/rowSelectionFeature.ts

@@ -0,0 +1,164 @@
+import {
+  assignPrototypeAPIs,
+  assignTableAPIs,
+  makeStateUpdater,
+} from '../../utils'
+import {
+  getDefaultRowSelectionState,
+  row_getCanMultiSelect,
+  row_getCanSelect,
+  row_getCanSelectSubRows,
+  row_getIsAllSubRowsSelected,
+  row_getIsSelected,
+  row_getIsSomeSelected,
+  row_getToggleSelectedHandler,
+  row_toggleSelected,
+  table_getFilteredSelectedRowModel,
+  table_getGroupedSelectedRowModel,
+  table_getIsAllPageRowsSelected,
+  table_getIsAllRowsSelected,
+  table_getIsSomePageRowsSelected,
+  table_getIsSomeRowsSelected,
+  table_getPreSelectedRowModel,
+  table_getSelectedRowModel,
+  table_getToggleAllPageRowsSelectedHandler,
+  table_getToggleAllRowsSelectedHandler,
+  table_resetRowSelection,
+  table_setRowSelection,
+  table_toggleAllPageRowsSelected,
+  table_toggleAllRowsSelected,
+} from './rowSelectionFeature.utils'
+import type { RowData } from '../../types/type-utils'
+import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
+// import type {
+//   Row_RowSelection,
+//   TableOptions_RowSelection,
+//   TableState_RowSelection,
+//   Table_RowSelection,
+// } from './rowSelectionFeature.types'
+
+interface RowSelectionFeatureConstructors<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  // Row: Row_RowSelection
+  // Table: Table_RowSelection<TFeatures, TData>
+  // TableOptions: TableOptions_RowSelection<TFeatures, TData>
+  // TableState: TableState_RowSelection
+}
+
+export function constructRowSelectionFeature<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(): TableFeature<RowSelectionFeatureConstructors<TFeatures, TData>> {
+  return {
+    getInitialState: (initialState) => {
+      return {
+        rowSelection: getDefaultRowSelectionState(),
+        ...initialState,
+      }
+    },
+
+    getDefaultTableOptions: (table) => {
+      return {
+        onRowSelectionChange: makeStateUpdater('rowSelection', table),
+        enableRowSelection: true,
+        enableMultiRowSelection: true,
+        enableSubRowSelection: true,
+      }
+    },
+
+    assignRowPrototype: (prototype, table) => {
+      assignPrototypeAPIs('rowSelectionFeature', prototype, table, {
+        row_toggleSelected: {
+          fn: (row, value, opts) => row_toggleSelected(row, value, opts),
+        },
+        row_getIsSelected: {
+          fn: (row) => row_getIsSelected(row),
+        },
+        row_getIsSomeSelected: {
+          fn: (row) => row_getIsSomeSelected(row),
+        },
+        row_getIsAllSubRowsSelected: {
+          fn: (row) => row_getIsAllSubRowsSelected(row),
+        },
+        row_getCanSelect: {
+          fn: (row) => row_getCanSelect(row),
+        },
+        row_getCanSelectSubRows: {
+          fn: (row) => row_getCanSelectSubRows(row),
+        },
+        row_getCanMultiSelect: {
+          fn: (row) => row_getCanMultiSelect(row),
+        },
+        row_getToggleSelectedHandler: {
+          fn: (row) => row_getToggleSelectedHandler(row),
+        },
+      })
+    },
+
+    constructTableAPIs: (table) => {
+      assignTableAPIs('rowSelectionFeature', table, {
+        table_setRowSelection: {
+          fn: (updater) => table_setRowSelection(table, updater),
+        },
+        table_resetRowSelection: {
+          fn: (defaultState) => table_resetRowSelection(table, defaultState),
+        },
+        table_toggleAllRowsSelected: {
+          fn: (value) => table_toggleAllRowsSelected(table, value),
+        },
+        table_toggleAllPageRowsSelected: {
+          fn: (value) => table_toggleAllPageRowsSelected(table, value),
+        },
+        table_getPreSelectedRowModel: {
+          fn: () => table_getPreSelectedRowModel(table),
+        },
+        table_getSelectedRowModel: {
+          fn: () => table_getSelectedRowModel(table),
+          memoDeps: () => [
+            table.store.state.rowSelection,
+            table.getCoreRowModel(),
+          ],
+        },
+        table_getFilteredSelectedRowModel: {
+          fn: () => table_getFilteredSelectedRowModel(table),
+          memoDeps: () => [
+            table.store.state.rowSelection,
+            table.getFilteredRowModel(),
+          ],
+        },
+        table_getGroupedSelectedRowModel: {
+          fn: () => table_getGroupedSelectedRowModel(table),
+          memoDeps: () => [
+            table.store.state.rowSelection,
+            table.getSortedRowModel(),
+          ],
+        },
+        table_getIsAllRowsSelected: {
+          fn: () => table_getIsAllRowsSelected(table),
+        },
+        table_getIsAllPageRowsSelected: {
+          fn: () => table_getIsAllPageRowsSelected(table),
+        },
+        table_getIsSomeRowsSelected: {
+          fn: () => table_getIsSomeRowsSelected(table),
+        },
+        table_getIsSomePageRowsSelected: {
+          fn: () => table_getIsSomePageRowsSelected(table),
+        },
+        table_getToggleAllRowsSelectedHandler: {
+          fn: () => table_getToggleAllRowsSelectedHandler(table),
+        },
+        table_getToggleAllPageRowsSelectedHandler: {
+          fn: () => table_getToggleAllPageRowsSelectedHandler(table),
+        },
+      })
+    },
+  }
+}
+
+/**
+ * The Row Selection feature adds row selection state and APIs to the table and row objects.
+ */
+export const rowSelectionFeature = constructRowSelectionFeature()

package/src/features/row-selection/rowSelectionFeature.types.ts

@@ -0,0 +1,143 @@
+import type { 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'
+
+export type RowSelectionState = Record<string, boolean>
+
+export interface TableState_RowSelection {
+  rowSelection: RowSelectionState
+}
+
+export interface TableOptions_RowSelection<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * - Enables/disables multiple row selection for all rows in the table OR
+   * - A function that given a row, returns whether to enable/disable multiple row selection for that row's children/grandchildren
+   */
+  enableMultiRowSelection?: boolean | ((row: Row<TFeatures, TData>) => boolean)
+  /**
+   * - Enables/disables row selection for all rows in the table OR
+   * - A function that given a row, returns whether to enable/disable row selection for that row
+   */
+  enableRowSelection?: boolean | ((row: Row<TFeatures, TData>) => boolean)
+  /**
+   * Enables/disables automatic sub-row selection when a parent row is selected, or a function that enables/disables automatic sub-row selection for each row.
+   * (Use in combination with expanding or grouping features)
+   */
+  enableSubRowSelection?: boolean | ((row: Row<TFeatures, TData>) => boolean)
+  /**
+   * If provided, this function will be called with an `updaterFn` when `state.rowSelection` 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.
+   */
+  onRowSelectionChange?: OnChangeFn<RowSelectionState>
+  // enableGroupingRowSelection?:
+  //   | boolean
+  //   | ((
+  //       row: Row<TFeatures, TData>
+  //     ) => boolean)
+  // isAdditiveSelectEvent?: (e: unknown) => boolean
+  // isInclusiveSelectEvent?: (e: unknown) => boolean
+  // selectRowsFn?: (
+  //   table: Table<TFeatures, TData>,
+  //   rowModel: RowModel<TFeatures, TData>
+  // ) => RowModel<TFeatures, TData>
+}
+
+export interface Row_RowSelection {
+  /**
+   * Returns whether or not the row can multi-select.
+   */
+  getCanMultiSelect: () => boolean
+  /**
+   * Returns whether or not the row can be selected.
+   */
+  getCanSelect: () => boolean
+  /**
+   * Returns whether or not the row can select sub rows automatically when the parent row is selected.
+   */
+  getCanSelectSubRows: () => boolean
+  /**
+   * Returns whether or not all of the row's sub rows are selected.
+   */
+  getIsAllSubRowsSelected: () => boolean
+  /**
+   * Returns whether or not the row is selected.
+   */
+  getIsSelected: () => boolean
+  /**
+   * Returns whether or not some of the row's sub rows are selected.
+   */
+  getIsSomeSelected: () => boolean
+  /**
+   * Returns a handler that can be used to toggle the row.
+   */
+  getToggleSelectedHandler: () => (event: unknown) => void
+  /**
+   * Selects/deselects the row.
+   */
+  toggleSelected: (value?: boolean, opts?: { selectChildren?: boolean }) => void
+}
+
+export interface Table_RowSelection<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Returns the row model of all rows that are selected after filtering has been applied.
+   */
+  getFilteredSelectedRowModel: () => RowModel<TFeatures, TData>
+  /**
+   * Returns the row model of all rows that are selected after grouping has been applied.
+   */
+  getGroupedSelectedRowModel: () => RowModel<TFeatures, TData>
+  /**
+   * Returns whether or not all rows on the current page are selected.
+   */
+  getIsAllPageRowsSelected: () => boolean
+  /**
+   * Returns whether or not all rows in the table are selected.
+   */
+  getIsAllRowsSelected: () => boolean
+  /**
+   * Returns whether or not any rows on the current page are selected.
+   */
+  getIsSomePageRowsSelected: () => boolean
+  /**
+   * Returns whether or not any rows in the table are selected.
+   */
+  getIsSomeRowsSelected: () => boolean
+  /**
+   * Returns the core row model of all rows before row selection has been applied.
+   */
+  getPreSelectedRowModel: () => RowModel<TFeatures, TData>
+  /**
+   * Returns the row model of all rows that are selected.
+   */
+  getSelectedRowModel: () => RowModel<TFeatures, TData>
+  /**
+   * Returns a handler that can be used to toggle all rows on the current page.
+   */
+  getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void
+  /**
+   * Returns a handler that can be used to toggle all rows in the table.
+   */
+  getToggleAllRowsSelectedHandler: () => (event: unknown) => void
+  /**
+   * Resets the **rowSelection** state to the `initialState.rowSelection`, or `true` can be passed to force a default blank state reset to `{}`.
+   */
+  resetRowSelection: (defaultState?: boolean) => void
+  /**
+   * Sets or updates the `state.rowSelection` state.
+   */
+  setRowSelection: (updater: Updater<RowSelectionState>) => void
+  /**
+   * Selects/deselects all rows on the current page.
+   */
+  toggleAllPageRowsSelected: (value?: boolean) => void
+  /**
+   * Selects/deselects all rows in the table.
+   */
+  toggleAllRowsSelected: (value?: boolean) => void
+}