@tanstack/table-core 9.0.0-beta.5 → 9.0.0-beta.51

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

@@ -1,10 +1,19 @@
-import { cloneState } from '../../utils'
+import {
+  callMemoOrStaticFn,
+  cloneState,
+  copyInstancePropertiesWithoutMemos,
+  hasOwn,
+  makeObjectMap,
+} from '../../utils'
 import type { RowData, Updater } 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 { Row } from '../../types/Row'
-import type { RowSelectionState } from './rowSelectionFeature.types'
+import type {
+  RowSelectionState,
+  ToggleSelectedOptions,
+} from './rowSelectionFeature.types'
 
 // State APIs
 
@@ -20,7 +29,7 @@ import type { RowSelectionState } from './rowSelectionFeature.types'
  * ```
  */
 export function getDefaultRowSelectionState(): RowSelectionState {
-  return {}
+  return makeObjectMap()
 }
 
 /**
@@ -60,9 +69,16 @@ export function table_resetRowSelection<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {
+  // @ts-ignore - _lastSelectedRowId is part of the RowSelection feature
+  table._lastSelectedRowId = null
   table_setRowSelection(
     table,
-    defaultState ? {} : cloneState(table.initialState.rowSelection ?? {}),
+    defaultState
+      ? makeObjectMap()
+      : Object.assign(
+          makeObjectMap<true>(),
+          cloneState(table.initialState.rowSelection ?? {}),
+        ),
   )
 }
 
@@ -82,23 +98,38 @@ export function table_resetRowSelection<
 export function table_toggleAllRowsSelected<
   TFeatures extends TableFeatures,
   TData extends RowData,
->(table: Table_Internal<TFeatures, TData>, value?: boolean) {
+>(
+  table: Table_Internal<TFeatures, TData>,
+  value?: boolean,
+  opts?: { deselectAll?: boolean },
+) {
+  // @ts-ignore - _lastSelectedRowId is part of the RowSelection feature
+  table._lastSelectedRowId = null
   table_setRowSelection(table, (old) => {
     value =
-      typeof value !== 'undefined' ? value : !table_getIsAllRowsSelected(table)
-
-    const rowSelection = { ...old }
+      typeof value !== 'undefined'
+        ? value
+        : !callMemoOrStaticFn(
+            table,
+            'getIsAllRowsSelected',
+            table_getIsAllRowsSelected,
+          )
+
+    if (opts?.deselectAll && !value) {
+      // deselectAll opt: clear the whole selection map instead of deleting ids one-by-one
+      return makeObjectMap<true>()
+    }
 
+    const rowSelection = Object.assign(makeObjectMap<true>(), old)
     const preGroupedFlatRows = table.getPreGroupedRowModel().flatRows
 
     // We don't use `mutateRowIsSelected` here for performance reasons.
     // All of the rows are flat already, so it wouldn't be worth it
     if (value) {
       preGroupedFlatRows.forEach((row) => {
-        if (!row_getCanSelect(row)) {
-          return
+        if (row_getCanSelect(row)) {
+          rowSelection[row.id] = true
         }
-        rowSelection[row.id] = true
       })
     } else {
       preGroupedFlatRows.forEach((row) => {
@@ -124,14 +155,32 @@ export function table_toggleAllRowsSelected<
 export function table_toggleAllPageRowsSelected<
   TFeatures extends TableFeatures,
   TData extends RowData,
->(table: Table_Internal<TFeatures, TData>, value?: boolean) {
+>(
+  table: Table_Internal<TFeatures, TData>,
+  value?: boolean,
+  opts?: { deselectAll?: boolean },
+) {
+  // @ts-ignore - _lastSelectedRowId is part of the RowSelection feature
+  table._lastSelectedRowId = null
   table_setRowSelection(table, (old) => {
     const resolvedValue =
       typeof value !== 'undefined'
         ? value
-        : !table_getIsAllPageRowsSelected(table)
+        : !callMemoOrStaticFn(
+            table,
+            'getIsAllPageRowsSelected',
+            table_getIsAllPageRowsSelected,
+          )
+
+    if (opts?.deselectAll && !resolvedValue) {
+      // deselectAll opt: clear the whole selection map instead of deleting ids one-by-one
+      return makeObjectMap<true>()
+    }
 
-    const rowSelection: RowSelectionState = { ...old }
+    const rowSelection: RowSelectionState = Object.assign(
+      makeObjectMap<true>(),
+      old,
+    )
 
     table.getRowModel().rows.forEach((row) => {
       mutateRowIsSelected(rowSelection, row.id, resolvedValue, true, table)
@@ -176,15 +225,21 @@ export function table_getSelectedRowModel<
 >(table: Table_Internal<TFeatures, TData>) {
   const rowModel = table.getCoreRowModel()
 
-  if (!Object.keys(table.atoms.rowSelection?.get() ?? {}).length) {
+  if (
+    !callMemoOrStaticFn(
+      table,
+      'getIsSomeRowsSelected',
+      table_getIsSomeRowsSelected,
+    )
+  ) {
     return {
       rows: [],
       flatRows: [],
-      rowsById: {},
+      rowsById: makeObjectMap(),
     }
   }
 
-  return selectRowsFn(rowModel)
+  return selectRowsFn(rowModel, table)
 }
 
 /**
@@ -202,17 +257,23 @@ export function table_getFilteredSelectedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
-  const rowModel = table.getCoreRowModel()
+  const rowModel = table.getFilteredRowModel()
 
-  if (!Object.keys(table.atoms.rowSelection?.get() ?? {}).length) {
+  if (
+    !callMemoOrStaticFn(
+      table,
+      'getIsSomeRowsSelected',
+      table_getIsSomeRowsSelected,
+    )
+  ) {
     return {
       rows: [],
       flatRows: [],
-      rowsById: {},
+      rowsById: makeObjectMap(),
     }
   }
 
-  return selectRowsFn(rowModel)
+  return selectRowsFn(rowModel, table)
 }
 
 /**
@@ -230,17 +291,40 @@ export function table_getGroupedSelectedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
-  const rowModel = table.getCoreRowModel()
+  // The sorted model falls back grouped -> filtered -> core when those
+  // features are not registered, so selected group rows are always visible.
+  const rowModel = table.getSortedRowModel()
 
-  if (!Object.keys(table.atoms.rowSelection?.get() ?? {}).length) {
+  if (
+    !callMemoOrStaticFn(
+      table,
+      'getIsSomeRowsSelected',
+      table_getIsSomeRowsSelected,
+    )
+  ) {
     return {
       rows: [],
       flatRows: [],
-      rowsById: {},
+      rowsById: makeObjectMap(),
     }
   }
 
-  return selectRowsFn(rowModel)
+  return selectRowsFn(rowModel, table)
+}
+
+/**
+ * Returns the ids of all selected rows.
+ *
+ * @example
+ * ```ts
+ * const selectedRowIds = table_getSelectedRowIds(table)
+ * ```
+ */
+export function table_getSelectedRowIds<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): Array<string> {
+  return Object.keys(table.atoms.rowSelection?.get() ?? {})
 }
 
 /**
@@ -259,7 +343,7 @@ export function table_getIsAllRowsSelected<
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
   const preGroupedFlatRows = table.getFilteredRowModel().flatRows
-  const rowSelection: RowSelectionState = table.atoms.rowSelection?.get() ?? {}
+  const rowSelection = table.atoms.rowSelection?.get() ?? {}
 
   let isAllRowsSelected = Boolean(
     preGroupedFlatRows.length && Object.keys(rowSelection).length,
@@ -268,7 +352,7 @@ export function table_getIsAllRowsSelected<
   if (isAllRowsSelected) {
     if (
       preGroupedFlatRows.some(
-        (row) => row_getCanSelect(row) && !rowSelection[row.id],
+        (row) => row_getCanSelect(row) && !isRowSelected(row, rowSelection),
       )
     ) {
       isAllRowsSelected = false
@@ -295,13 +379,13 @@ export function table_getIsAllPageRowsSelected<
   const paginationFlatRows = table
     .getPaginatedRowModel()
     .flatRows.filter((row) => row_getCanSelect(row))
-  const rowSelection: RowSelectionState = table.atoms.rowSelection?.get() ?? {}
+  const rowSelection = table.atoms.rowSelection?.get() ?? {}
 
   let isAllPageRowsSelected = !!paginationFlatRows.length
 
   if (
     isAllPageRowsSelected &&
-    paginationFlatRows.some((row) => !rowSelection[row.id])
+    paginationFlatRows.some((row) => !isRowSelected(row, rowSelection))
   ) {
     isAllPageRowsSelected = false
   }
@@ -312,8 +396,7 @@ export function table_getIsAllPageRowsSelected<
 /**
  * Checks whether selection is partially applied across filtered rows.
  *
- * The result is true when at least one row id is selected but fewer ids are
- * selected than the current filtered flat row count.
+ * The result is true when at least one row id is selected
  *
  * @example
  * ```ts
@@ -324,21 +407,15 @@ export function table_getIsSomeRowsSelected<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
-  const totalSelected = Object.keys(
-    table.atoms.rowSelection?.get() ?? {},
-  ).length
   return (
-    totalSelected > 0 &&
-    totalSelected < table.getFilteredRowModel().flatRows.length
+    callMemoOrStaticFn(table, 'getSelectedRowIds', table_getSelectedRowIds)
+      .length > 0
   )
 }
 
 /**
  * Checks whether the current page has a partial selection.
  *
- * This is false when all selectable page rows are selected. Otherwise it is true
- * if any selectable page row or descendant is selected.
- *
  * @example
  * ```ts
  * const somePageRowsSelected = table_getIsSomePageRowsSelected(table)
@@ -348,12 +425,14 @@ export function table_getIsSomePageRowsSelected<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
-  const paginationFlatRows = table.getPaginatedRowModel().flatRows
-  return table_getIsAllPageRowsSelected(table)
-    ? false
-    : paginationFlatRows
-        .filter((row) => row_getCanSelect(row))
-        .some((row) => row_getIsSelected(row) || row_getIsSomeSelected(row))
+  return table
+    .getPaginatedRowModel()
+    .flatRows.filter((row) => row_getCanSelect(row))
+    .some(
+      (row) =>
+        row_getIsSelected(row) ||
+        callMemoOrStaticFn(row, 'getIsSomeSelected', row_getIsSomeSelected),
+    )
 }
 
 /**
@@ -413,38 +492,32 @@ export function table_getToggleAllPageRowsSelectedHandler<
  * @example
  * ```ts
  * row_toggleSelected(row)
+ * row_toggleSelected(row, true)
+ * row_toggleSelected(row, false)
+ * row_toggleSelected(row, true, { selectChildren: false })
+ * row_toggleSelected(row, false, { selectChildren: false })
  * ```
  */
 export function row_toggleSelected<
   TFeatures extends TableFeatures,
   TData extends RowData,
->(
-  row: Row<TFeatures, TData>,
-  value?: boolean,
-  opts?: {
-    selectChildren?: boolean
-  },
-) {
+>(row: Row<TFeatures, TData>, value?: boolean, opts?: ToggleSelectedOptions) {
   const isSelected = row_getIsSelected(row)
 
   table_setRowSelection(row.table, (old) => {
     value = typeof value !== 'undefined' ? value : !isSelected
 
-    if (row_getCanSelect(row) && isSelected === value) {
-      return old
-    }
-
-    const selectedRowIds = { ...old }
+    const rowSelection = Object.assign(makeObjectMap<true>(), old)
 
     mutateRowIsSelected(
-      selectedRowIds,
+      rowSelection,
       row.id,
       value,
       opts?.selectChildren ?? true,
       row.table,
     )
 
-    return selectedRowIds
+    return rowSelection
   })
 }
 
@@ -462,7 +535,8 @@ export function row_getIsSelected<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(row: Row<TFeatures, TData>) {
-  return isRowSelected(row)
+  const rowSelection = row.table.atoms.rowSelection?.get() ?? {}
+  return isRowSelected(row, rowSelection)
 }
 
 /**
@@ -572,7 +646,11 @@ export function row_getCanMultiSelect<
  * Creates a checkbox-style handler that selects or deselects this row.
  *
  * The handler is a no-op when the row cannot be selected and reads
- * `event.target.checked`.
+ * `event.target.checked`. Shift events select or deselect the inclusive range
+ * from the most recent selectable row handled by this table. The event's
+ * optional `persist()` method is called before it is read. Pass
+ * `selectChildren: false` to limit changes to rows explicitly present in the
+ * display-order interval.
  *
  * @example
  * ```ts
@@ -582,44 +660,137 @@ export function row_getCanMultiSelect<
 export function row_getToggleSelectedHandler<
   TFeatures extends TableFeatures,
   TData extends RowData,
->(row: Row<TFeatures, TData>) {
+>(row: Row<TFeatures, TData>, opts?: ToggleSelectedOptions) {
   const canSelect = row_getCanSelect(row)
 
   return (e: unknown) => {
     if (!canSelect) return
-    row_toggleSelected(
-      row,
-      ((e as MouseEvent).target as HTMLInputElement).checked,
-    )
+
+    const event = e as {
+      persist?: () => void
+      target: { checked: boolean }
+    }
+    event.persist?.()
+
+    const table = row.table
+    const checked = event.target.checked
+    // @ts-ignore - _lastSelectedRowId is part of the RowSelection feature
+    const anchorId = table._lastSelectedRowId
+    const canSelectRange =
+      table.options.enableRowRangeSelection !== false &&
+      anchorId !== null &&
+      row_getCanMultiSelect(row) &&
+      (table.options.isRowRangeSelectionEvent?.(e) ?? false)
+
+    if (
+      !canSelectRange ||
+      !selectRowRange(row, anchorId, checked, opts?.selectChildren ?? true)
+    ) {
+      row_toggleSelected(row, checked, opts)
+    }
+
+    // @ts-ignore - _lastSelectedRowId is part of the RowSelection feature
+    table._lastSelectedRowId = row.id
   }
 }
 
+/**
+ * Resolves and mutates an inclusive interval in the table's latest logical
+ * display order.
+ *
+ * The anchor is resolved without throwing from the pre-pagination row model,
+ * then the core row model. Both endpoint display indexes must still identify
+ * those rows in the current order and both endpoints must support
+ * multi-selection. Eligible interval rows are applied through one row
+ * selection updater; non-selectable and non-multi-selectable rows are skipped.
+ * Returns `false` when the interaction should fall back to an ordinary toggle.
+ */
+function selectRowRange<TFeatures extends TableFeatures, TData extends RowData>(
+  row: Row<TFeatures, TData>,
+  anchorId: string,
+  value: boolean,
+  includeChildren: boolean,
+): boolean {
+  const table = row.table
+  const rows = table.getRowsInDisplayOrder()
+  const anchorRow =
+    table.getPrePaginatedRowModel().rowsById[anchorId] ??
+    table.getCoreRowModel().rowsById[anchorId]
+
+  if (!anchorRow) {
+    return false
+  }
+
+  const anchorIndex = anchorRow.getDisplayIndex()
+  const rowIndex = row.getDisplayIndex()
+  const anchorAtIndex = rows[anchorIndex]
+  const rowAtIndex = rows[rowIndex]
+
+  if (
+    anchorIndex < 0 ||
+    rowIndex < 0 ||
+    anchorIndex >= rows.length ||
+    rowIndex >= rows.length ||
+    anchorAtIndex?.id !== anchorRow.id ||
+    rowAtIndex?.id !== row.id ||
+    !row_getCanMultiSelect(anchorRow) ||
+    !row_getCanMultiSelect(row)
+  ) {
+    return false
+  }
+
+  const start = Math.min(anchorIndex, rowIndex)
+  const end = Math.max(anchorIndex, rowIndex)
+
+  table_setRowSelection(table, (old) => {
+    const rowSelection = Object.assign(makeObjectMap<true>(), old)
+
+    for (let index = start; index <= end; index++) {
+      const rangeRow = rows[index]!
+      if (!row_getCanSelect(rangeRow) || !row_getCanMultiSelect(rangeRow)) {
+        continue
+      }
+      mutateRowIsSelected(
+        rowSelection,
+        rangeRow.id,
+        value,
+        includeChildren,
+        table,
+      )
+    }
+
+    return rowSelection
+  })
+
+  return true
+}
+
 const mutateRowIsSelected = <
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(
-  selectedRowIds: Record<string, boolean | undefined>,
+  rowSelection: RowSelectionState,
   rowId: string,
   value: boolean,
   includeChildren: boolean,
   table: Table_Internal<TFeatures, TData>,
-) => {
+): void => {
   const row = table.getRow(rowId, true)
 
   if (value) {
     if (!row_getCanMultiSelect(row)) {
-      Object.keys(selectedRowIds).forEach((key) => delete selectedRowIds[key])
+      Object.keys(rowSelection).forEach((key) => delete rowSelection[key])
     }
     if (row_getCanSelect(row)) {
-      selectedRowIds[rowId] = true
+      rowSelection[rowId] = true
     }
   } else {
-    delete selectedRowIds[rowId]
+    delete rowSelection[rowId]
   }
 
   if (includeChildren && row.subRows.length && row_getCanSelectSubRows(row)) {
     row.subRows.forEach((r) =>
-      mutateRowIsSelected(selectedRowIds, r.id, value, includeChildren, table),
+      mutateRowIsSelected(rowSelection, r.id, value, includeChildren, table),
     )
   }
 }
@@ -638,10 +809,13 @@ const mutateRowIsSelected = <
 export function selectRowsFn<
   TFeatures extends TableFeatures,
   TData extends RowData,
->(rowModel: RowModel<TFeatures, TData>): RowModel<TFeatures, TData> {
+>(
+  rowModel: RowModel<TFeatures, TData>,
+  table: Table_Internal<TFeatures, TData>,
+): RowModel<TFeatures, TData> {
   const newSelectedFlatRows: Array<Row<TFeatures, TData>> = []
-  const newSelectedRowsById: Record<string, Row<TFeatures, TData>> = {}
-
+  const newSelectedRowsById = makeObjectMap<Row<TFeatures, TData>>()
+  const rowSelection = table.atoms.rowSelection?.get() ?? {}
   // Filters top level and nested rows.
   const recurseRows = (
     rows: Array<Row<TFeatures, TData>>,
@@ -649,8 +823,8 @@ export function selectRowsFn<
   ): Array<Row<TFeatures, TData>> => {
     const result: Array<Row<TFeatures, TData>> = []
     for (let i = 0; i < rows.length; i++) {
-      let row = rows[i]!
-      const isSelected = isRowSelected(row)
+      const row = rows[i]!
+      const isSelected = isRowSelected(row, rowSelection)
 
       if (isSelected) {
         newSelectedFlatRows.push(row)
@@ -658,13 +832,18 @@ export function selectRowsFn<
       }
 
       if (row.subRows.length) {
-        row = {
-          ...row,
-          subRows: recurseRows(row.subRows, depth + 1),
+        // Always recurse — selected descendants of unselected parents must
+        // still be collected into flatRows/rowsById.
+        const newSubRows = recurseRows(row.subRows, depth + 1)
+
+        if (isSelected) {
+          // Preserve prototype chain so methods like getValue() remain accessible
+          const cloned = Object.create(Object.getPrototypeOf(row))
+          copyInstancePropertiesWithoutMemos(cloned, row)
+          cloned.subRows = newSubRows
+          result.push(cloned)
         }
-      }
-
-      if (isSelected) {
+      } else if (isSelected) {
         result.push(row)
       }
     }
@@ -689,8 +868,8 @@ export function selectRowsFn<
 export function isRowSelected<
   TFeatures extends TableFeatures,
   TData extends RowData,
->(row: Row<TFeatures, TData>): boolean {
-  return (row.table.atoms.rowSelection?.get() ?? {})[row.id] ?? false
+>(row: Row<TFeatures, TData>, rowSelection: RowSelectionState): boolean {
+  return !!(hasOwn(rowSelection, row.id) && rowSelection[row.id])
 }
 
 /**
@@ -709,17 +888,21 @@ export function isSubRowSelected<
 >(row: Row<TFeatures, TData>): boolean | 'some' | 'all' {
   if (!row.subRows.length) return false
 
-  let allChildrenSelected = true
+  const rowSelection = row.table.atoms.rowSelection?.get() ?? {}
+
   let someSelected = false
+  let allChildrenSelected = true
+
+  for (let i = 0; i < row.subRows.length; i++) {
+    const subRow = row.subRows[i]!
 
-  row.subRows.forEach((subRow) => {
     // Bail out early if we know both of these
     if (someSelected && !allChildrenSelected) {
-      return
+      break
     }
 
     if (row_getCanSelect(subRow)) {
-      if (isRowSelected(subRow)) {
+      if (isRowSelected(subRow, rowSelection)) {
         someSelected = true
       } else {
         allChildrenSelected = false
@@ -738,8 +921,7 @@ export function isSubRowSelected<
         allChildrenSelected = false
       }
     }
-  })
+  }
 
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   return allChildrenSelected ? 'all' : someSelected ? 'some' : false
 }