@tanstack/table-core 9.0.0-beta.7 → 9.0.0-beta.70

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

@@ -1,323 +0,0 @@
-import { row_getIsAllParentsExpanded } from '../row-expanding/rowExpandingFeature.utils'
-import { callMemoOrStaticFn, cloneState } 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
-
-/**
- * Creates the default row pinning state.
- *
- * Both pinning regions start empty. Reset APIs use this value when
- * `defaultState` is `true`.
- *
- * @example
- * ```ts
- * const pinning = getDefaultRowPinningState()
- * ```
- */
-export function getDefaultRowPinningState(): RowPinningState {
-  return {
-    top: [],
-    bottom: [],
-  }
-}
-
-/**
- * Routes a row pinning updater through the table's row-pinning change handler.
- *
- * The updater may be a next `{ top, bottom }` state or a function of the
- * previous state, matching the instance `table.setRowPinning` behavior.
- *
- * @example
- * ```ts
- * table_setRowPinning(table, (old) => ({ ...old, top: [rowId] }))
- * ```
- */
-export function table_setRowPinning<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  table: Table_Internal<TFeatures, TData>,
-  updater: Updater<RowPinningState>,
-): void {
-  table.options.onRowPinningChange?.(updater)
-}
-
-/**
- * Resets `rowPinning` to the configured initial state or feature default.
- *
- * With no argument, the reset clones `table.initialState.rowPinning` when it
- * exists. Passing `true` ignores initial state and resets to empty top/bottom
- * arrays.
- *
- * @example
- * ```ts
- * table_resetRowPinning(table)
- * table_resetRowPinning(table, true)
- * ```
- */
-export function table_resetRowPinning<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void {
-  table_setRowPinning(
-    table,
-    defaultState
-      ? getDefaultRowPinningState()
-      : cloneState(
-          table.initialState.rowPinning ?? getDefaultRowPinningState(),
-        ),
-  )
-}
-
-// Table Utils
-
-/**
- * Checks whether any rows are pinned.
- *
- * Omit `position` to check both regions, or pass `'top'`/`'bottom'` to inspect
- * one region.
- *
- * @example
- * ```ts
- * const hasPinnedRows = table_getIsSomeRowsPinned(table)
- * ```
- */
-export function table_getIsSomeRowsPinned<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  table: Table_Internal<TFeatures, TData>,
-  position?: RowPinningPosition,
-): boolean {
-  const rowPinning = table.atoms.rowPinning?.get()
-
-  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.atoms.rowPinning?.get()?.[position] ?? []
-  const keepPinnedRows = table.options.keepPinnedRows ?? true
-
-  const result: Array<Row<TFeatures, TData>> = []
-  for (let i = 0; i < pinnedRowIds.length; i++) {
-    const rowId = pinnedRowIds[i]!
-    let row: Row<TFeatures, TData> | undefined
-    if (keepPinnedRows) {
-      // get all rows that are pinned even if they would not be otherwise
-      // visible; account for expanded parent rows, but not pagination/filtering
-      const fullRow = table.getRow(rowId, true)
-      if (row_getIsAllParentsExpanded(fullRow)) row = fullRow
-    } else {
-      // else get only visible rows that are pinned
-      row = visibleRows.find((r) => r.id === rowId)
-    }
-    if (!row)
-      continue
-      // Assign position property directly to preserve prototype chain
-    ;(row as any).position = position
-    result.push(row)
-  }
-  return result
-}
-
-/**
- * Resolves the visible rows pinned to the top region.
- *
- * The result follows `state.rowPinning.top` order and marks each row with
- * `position = 'top'`.
- *
- * @example
- * ```ts
- * const rows = table_getTopRows(table)
- * ```
- */
-export function table_getTopRows<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): Array<Row<TFeatures, TData>> {
-  return table_getPinnedRows(table, 'top')
-}
-
-/**
- * Resolves the visible rows pinned to the bottom region.
- *
- * The result follows `state.rowPinning.bottom` order and marks each row with
- * `position = 'bottom'`.
- *
- * @example
- * ```ts
- * const rows = table_getBottomRows(table)
- * ```
- */
-export function table_getBottomRows<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): Array<Row<TFeatures, TData>> {
-  return table_getPinnedRows(table, 'bottom')
-}
-
-/**
- * Resolves rows that are not pinned to top or bottom.
- *
- * The current row model is filtered by `state.rowPinning.top` and
- * `state.rowPinning.bottom`.
- *
- * @example
- * ```ts
- * const rows = table_getCenterRows(table)
- * ```
- */
-export function table_getCenterRows<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): Array<Row<TFeatures, TData>> {
-  const { top, bottom } =
-    table.atoms.rowPinning?.get() ?? getDefaultRowPinningState()
-  const allRows = table.getRowModel().rows
-
-  const topAndBottom = new Set([...top, ...bottom])
-  return allRows.filter((d) => !topAndBottom.has(d.id))
-}
-
-// Row Utils
-
-/**
- * Checks whether this row can be pinned.
- *
- * `options.enableRowPinning` may be a boolean or a row predicate; it defaults
- * to `true`.
- *
- * @example
- * ```ts
- * const canPin = row_getCanPin(row)
- * ```
- */
-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
-}
-
-/**
- * Reads this row's current pinning region.
- *
- * Rows listed in `state.rowPinning.top` return `'top'`, rows listed in
- * `bottom` return `'bottom'`, and unpinned rows return `false`.
- *
- * @example
- * ```ts
- * const position = row_getIsPinned(row)
- * ```
- */
-export function row_getIsPinned<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(row: Row<TFeatures, TData>): RowPinningPosition {
-  const { top, bottom } =
-    row.table.atoms.rowPinning?.get() ?? getDefaultRowPinningState()
-
-  return top.includes(row.id)
-    ? 'top'
-    : bottom.includes(row.id)
-      ? 'bottom'
-      : false
-}
-
-/**
- * Finds this row's visible index within its pinned region.
- *
- * Unpinned rows return `-1`.
- *
- * @example
- * ```ts
- * const index = row_getPinnedIndex(row)
- * ```
- */
-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)
-}
-
-/**
- * Pins or unpins a row.
- *
- * Optional flags let callers include parent rows or leaf rows when updating
- * the row pinning state.
- *
- * @example
- * ```ts
- * row_pin(row, 'top')
- * ```
- */
-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

@@ -1,140 +0,0 @@
-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 { TableFeature } from '../../types/TableFeatures'
-
-/**
- * Feature that adds row selection state and APIs for row and page selection.
- */
-export const rowSelectionFeature: TableFeature = {
-  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.atoms.rowSelection?.get(),
-          table.getCoreRowModel(),
-        ],
-      },
-      table_getFilteredSelectedRowModel: {
-        fn: () => table_getFilteredSelectedRowModel(table),
-        memoDeps: () => [
-          table.atoms.rowSelection?.get(),
-          table.getFilteredRowModel(),
-        ],
-      },
-      table_getGroupedSelectedRowModel: {
-        fn: () => table_getGroupedSelectedRowModel(table),
-        memoDeps: () => [
-          table.atoms.rowSelection?.get(),
-          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),
-      },
-    })
-  },
-}

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

@@ -1,151 +0,0 @@
-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 | undefined>
-
-export interface TableState_RowSelection {
-  rowSelection: RowSelectionState
-}
-
-export interface TableOptions_RowSelection<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * Allows rows to be selected alongside other rows.
-   *
-   * Provide a predicate to decide per row. Defaults to `true`.
-   */
-  enableMultiRowSelection?: boolean | ((row: Row<TFeatures, TData>) => boolean)
-  /**
-   * Allows rows to be selected.
-   *
-   * Provide a predicate to decide per row. Defaults to `true`.
-   */
-  enableRowSelection?: boolean | ((row: Row<TFeatures, TData>) => boolean)
-  /**
-   * Controls whether selecting a parent row also selects its subRows.
-   *
-   * Provide a predicate to decide per row. This is most useful with expanding or
-   * grouping features and defaults to `true`.
-   */
-  enableSubRowSelection?: boolean | ((row: Row<TFeatures, TData>) => boolean)
-  /**
-   * Called with an updater when row selection state changes. Pair this with
-   * `state.rowSelection` when using external state; external atoms can own the
-   * slice without this callback.
-   */
-  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 {
-  /**
-   * Checks whether this row can be selected alongside other rows.
-   */
-  getCanMultiSelect: () => boolean
-  /**
-   * Checks whether this row can currently be selected.
-   */
-  getCanSelect: () => boolean
-  /**
-   * Checks whether selecting this row should also select its subRows.
-   */
-  getCanSelectSubRows: () => boolean
-  /**
-   * Checks whether all selectable descendants are selected.
-   */
-  getIsAllSubRowsSelected: () => boolean
-  /**
-   * Checks whether this row id is selected.
-   */
-  getIsSelected: () => boolean
-  /**
-   * Checks whether some selectable descendants are selected.
-   */
-  getIsSomeSelected: () => boolean
-  /**
-   * Creates a checkbox-style handler that toggles this row's selected state.
-   */
-  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,
-> {
-  /**
-   * Builds a selected-row model from rows after filtering.
-   */
-  getFilteredSelectedRowModel: () => RowModel<TFeatures, TData>
-  /**
-   * Builds a selected-row model from rows after grouping.
-   */
-  getGroupedSelectedRowModel: () => RowModel<TFeatures, TData>
-  /**
-   * Checks whether every selectable row on the current page is selected.
-   */
-  getIsAllPageRowsSelected: () => boolean
-  /**
-   * Checks whether every selectable filtered row is selected.
-   */
-  getIsAllRowsSelected: () => boolean
-  /**
-   * Checks whether the current page has a partial row selection.
-   */
-  getIsSomePageRowsSelected: () => boolean
-  /**
-   * Checks whether filtered rows have a partial row selection.
-   */
-  getIsSomeRowsSelected: () => boolean
-  /**
-   * Returns the core row model of all rows before row selection has been applied.
-   */
-  getPreSelectedRowModel: () => RowModel<TFeatures, TData>
-  /**
-   * Builds a selected-row model from the core row model.
-   */
-  getSelectedRowModel: () => RowModel<TFeatures, TData>
-  /**
-   * Creates a checkbox-style handler that toggles all current-page rows.
-   */
-  getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void
-  /**
-   * Creates a checkbox-style handler that toggles all selectable rows.
-   */
-  getToggleAllRowsSelectedHandler: () => (event: unknown) => void
-  /**
-   * Resets `rowSelection` to `initialState.rowSelection`.
-   *
-   * Pass `true` to ignore initial state and reset to `{}`.
-   */
-  resetRowSelection: (defaultState?: boolean) => void
-  /**
-   * Updates row selection state with a next map or updater function.
-   */
-  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
-}