@tanstack/table-core 9.0.0-alpha.4 → 9.0.0-alpha.41

package/src/features/row-expanding/rowExpandingFeature.utils.ts

@@ -0,0 +1,208 @@
+import { 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 {
+  ExpandedState,
+  ExpandedStateList,
+} from './rowExpandingFeature.types'
+
+export function getDefaultExpandedState(): ExpandedState {
+  return {}
+}
+
+export function table_autoResetExpanded<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>) {
+  if (
+    table.options.autoResetAll ??
+    table.options.autoResetExpanded ??
+    !table.options.manualExpanding
+  ) {
+    queueMicrotask(() => table_resetExpanded(table))
+  }
+}
+
+export function table_setExpanded<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>, updater: Updater<ExpandedState>) {
+  table.options.onExpandedChange?.(updater)
+}
+
+export function table_toggleAllRowsExpanded<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>, expanded?: boolean) {
+  if (expanded ?? !table_getIsAllRowsExpanded(table)) {
+    table_setExpanded(table, true)
+  } else {
+    table_setExpanded(table, {})
+  }
+}
+
+export function table_resetExpanded<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {
+  table_setExpanded(
+    table,
+    defaultState ? {} : cloneState(table.initialState.expanded ?? {}),
+  )
+}
+
+export function table_getCanSomeRowsExpand<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>) {
+  return table
+    .getPrePaginatedRowModel()
+    .flatRows.some((row) => row_getCanExpand(row))
+}
+
+export function table_getToggleAllRowsExpandedHandler<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>) {
+  return (e: unknown) => {
+    ;(e as any).persist?.()
+    table_toggleAllRowsExpanded(table)
+  }
+}
+
+export function table_getIsSomeRowsExpanded<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>) {
+  const expanded = table.atoms.expanded?.get() ?? {}
+  return expanded === true || Object.values(expanded).some(Boolean)
+}
+
+export function table_getIsAllRowsExpanded<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>) {
+  const expanded = table.atoms.expanded?.get() ?? {}
+
+  // If expanded is true, save some cycles and return true
+  if (expanded === true) {
+    return true
+  }
+
+  if (!Object.keys(expanded).length) {
+    return false
+  }
+
+  // If any row is not expanded, return false
+  if (table.getRowModel().flatRows.some((row) => !row_getIsExpanded(row))) {
+    return false
+  }
+
+  // They must all be expanded :shrug:
+  return true
+}
+
+export function table_getExpandedDepth<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>) {
+  let maxDepth = 0
+
+  const rowIds =
+    table.atoms.expanded?.get() === true
+      ? Object.keys(table.getRowModel().rowsById)
+      : Object.keys(table.atoms.expanded?.get() ?? {})
+
+  rowIds.forEach((id) => {
+    const splitId = id.split('.')
+    maxDepth = Math.max(maxDepth, splitId.length)
+  })
+
+  return maxDepth
+}
+
+export function row_toggleExpanded<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(row: Row<TFeatures, TData>, expanded?: boolean) {
+  table_setExpanded(row.table, (old) => {
+    const exists = old === true ? true : !!old[row.id]
+
+    let oldExpanded: ExpandedStateList = {}
+
+    if (old === true) {
+      Object.keys(row.table.getRowModel().rowsById).forEach((rowId) => {
+        oldExpanded[rowId] = true
+      })
+    } else {
+      oldExpanded = old
+    }
+
+    expanded = expanded ?? !exists
+
+    if (!exists && expanded) {
+      return {
+        ...oldExpanded,
+        [row.id]: true,
+      }
+    }
+
+    if (exists && !expanded) {
+      const { [row.id]: _, ...rest } = oldExpanded
+      return rest
+    }
+
+    return old
+  })
+}
+
+export function row_getIsExpanded<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(row: Row<TFeatures, TData>) {
+  const expanded: ExpandedState = row.table.atoms.expanded?.get() ?? {}
+
+  return !!(
+    row.table.options.getIsRowExpanded?.(row) ??
+    (expanded === true || expanded[row.id])
+  )
+}
+
+export function row_getCanExpand<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(row: Row<TFeatures, TData>) {
+  return (
+    row.table.options.getRowCanExpand?.(row) ??
+    ((row.table.options.enableExpanding ?? true) && !!row.subRows.length)
+  )
+}
+
+export function row_getIsAllParentsExpanded<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(row: Row<TFeatures, TData>) {
+  let isFullyExpanded = true
+  let currentRow = row
+
+  while (isFullyExpanded && currentRow.parentId) {
+    currentRow = row.table.getRow(currentRow.parentId, true)
+    isFullyExpanded = row_getIsExpanded(row)
+  }
+
+  return isFullyExpanded
+}
+
+export function row_getToggleExpandedHandler<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(row: Row<TFeatures, TData>) {
+  const canExpand = row_getCanExpand(row)
+
+  return () => {
+    if (!canExpand) return
+    row_toggleExpanded(row)
+  }
+}

package/src/features/row-pagination/createPaginatedRowModel.ts

@@ -0,0 +1,78 @@
+import { tableMemo } from '../../utils'
+import { expandRows } from '../row-expanding/createExpandedRowModel'
+import { getDefaultPaginationState } from './rowPaginationFeature.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 { RowData } from '../../types/type-utils'
+
+export function createPaginatedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {
+  return (_table) => {
+    const table: Table_Internal<TFeatures, TData> = _table
+    return tableMemo({
+      feature: 'rowPaginationFeature',
+      table,
+      fnName: 'table.getPaginatedRowModel',
+      memoDeps: () => [
+        table.getPrePaginatedRowModel(),
+        table.atoms.pagination?.get(),
+        table.options.paginateExpandedRows
+          ? table.atoms.expanded?.get()
+          : undefined,
+      ],
+      fn: () => _createPaginatedRowModel(table),
+    })
+  }
+}
+
+function _createPaginatedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  const prePaginatedRowModel = table.getPrePaginatedRowModel()
+  const pagination = table.atoms.pagination?.get()
+
+  if (!prePaginatedRowModel.rows.length) {
+    return prePaginatedRowModel
+  }
+
+  const { pageSize, pageIndex } = pagination ?? getDefaultPaginationState()
+  const { rows, flatRows, rowsById } = prePaginatedRowModel
+  const pageStart = pageSize * pageIndex
+  const pageEnd = pageStart + pageSize
+
+  const paginatedRows = rows.slice(pageStart, pageEnd)
+
+  let paginatedRowModel: RowModel<TFeatures, TData>
+
+  if (!table.options.paginateExpandedRows) {
+    paginatedRowModel = expandRows({
+      rows: paginatedRows,
+      flatRows,
+      rowsById,
+    })
+  } else {
+    paginatedRowModel = {
+      rows: paginatedRows,
+      flatRows,
+      rowsById,
+    }
+  }
+
+  paginatedRowModel.flatRows = []
+
+  const handleRow = (row: Row<TFeatures, TData>) => {
+    paginatedRowModel.flatRows.push(row)
+    if (row.subRows.length) {
+      row.subRows.forEach(handleRow)
+    }
+  }
+
+  paginatedRowModel.rows.forEach(handleRow)
+
+  return paginatedRowModel
+}

package/src/features/row-pagination/rowPaginationFeature.ts

@@ -0,0 +1,121 @@
+import { assignTableAPIs, makeStateUpdater } from '../../utils'
+import {
+  getDefaultPaginationState,
+  table_autoResetPageIndex,
+  table_firstPage,
+  table_getCanNextPage,
+  table_getCanPreviousPage,
+  table_getPageCount,
+  table_getPageOptions,
+  table_getRowCount,
+  table_lastPage,
+  table_nextPage,
+  table_previousPage,
+  table_resetPageIndex,
+  table_resetPageSize,
+  table_resetPagination,
+  table_setPageIndex,
+  table_setPageSize,
+  table_setPagination,
+} from './rowPaginationFeature.utils'
+import type { RowData } from '../../types/type-utils'
+import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
+// import type {
+//   CachedRowModel_Paginated,
+//   CreateRowModel_Paginated,
+//   TableOptions_RowPagination,
+//   TableState_RowPagination,
+//   Table_RowPagination,
+// } from './rowPaginationFeature.types'
+
+export interface RowPaginationFeatureConstructors<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  // CachedRowModel: CachedRowModel_Paginated<TFeatures, TData>
+  // CreateRowModels: CreateRowModel_Paginated<TFeatures, TData>
+  // Table: Table_RowPagination<TFeatures, TData>
+  // TableOptions: TableOptions_RowPagination<TFeatures, TData>
+  // TableState: TableState_RowPagination
+}
+
+export function constructRowPaginationFeature<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(): TableFeature<RowPaginationFeatureConstructors<TFeatures, TData>> {
+  return {
+    getInitialState: (initialState) => {
+      return {
+        ...initialState,
+        pagination: {
+          ...getDefaultPaginationState(),
+          ...initialState.pagination,
+        },
+      }
+    },
+
+    getDefaultTableOptions: (table) => {
+      return {
+        onPaginationChange: makeStateUpdater('pagination', table),
+      }
+    },
+
+    constructTableAPIs: (table) => {
+      assignTableAPIs('rowPaginationFeature', table, {
+        table_autoResetPageIndex: {
+          fn: () => table_autoResetPageIndex(table),
+        },
+        table_setPagination: {
+          fn: (updater) => table_setPagination(table, updater),
+        },
+        table_resetPagination: {
+          fn: (defaultState) => table_resetPagination(table, defaultState),
+        },
+        table_setPageIndex: {
+          fn: (updater) => table_setPageIndex(table, updater),
+        },
+        table_resetPageIndex: {
+          fn: (defaultState) => table_resetPageIndex(table, defaultState),
+        },
+        table_setPageSize: {
+          fn: (updater) => table_setPageSize(table, updater),
+        },
+        table_getPageCount: {
+          fn: () => table_getPageCount(table),
+        },
+        table_resetPageSize: {
+          fn: (defaultState) => table_resetPageSize(table, defaultState),
+        },
+        table_getPageOptions: {
+          fn: () => table_getPageOptions(table),
+        },
+        table_getCanPreviousPage: {
+          fn: () => table_getCanPreviousPage(table),
+        },
+        table_getCanNextPage: {
+          fn: () => table_getCanNextPage(table),
+        },
+        table_previousPage: {
+          fn: () => table_previousPage(table),
+        },
+        table_nextPage: {
+          fn: () => table_nextPage(table),
+        },
+        table_firstPage: {
+          fn: () => table_firstPage(table),
+        },
+        table_lastPage: {
+          fn: () => table_lastPage(table),
+        },
+        table_getRowCount: {
+          fn: () => table_getRowCount(table),
+        },
+      })
+    },
+  }
+}
+
+/**
+ * The (Row) Pagination feature adds pagination state and APIs to the table object.
+ */
+export const rowPaginationFeature = constructRowPaginationFeature()

package/src/features/row-pagination/rowPaginationFeature.types.ts

@@ -0,0 +1,141 @@
+import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
+import type { Table } from '../../types/Table'
+import type { OnChangeFn, RowData, Updater } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+
+export interface PaginationState {
+  pageIndex: number
+  pageSize: number
+}
+
+export interface TableState_RowPagination {
+  pagination: PaginationState
+}
+
+export interface TableOptions_RowPagination {
+  /**
+   * If set to `true`, pagination will be reset to the first page when page-altering state changes eg. `data` is updated, filters change, grouping changes, etc.
+   */
+  autoResetPageIndex?: boolean
+  /**
+   * Enables manual pagination. If this option is set to `true`, the table will not automatically paginate rows using `getPaginatedRowModel()` and instead will expect you to manually paginate the rows before passing them to the table. This is useful if you are doing server-side pagination and aggregation.
+   */
+  manualPagination?: boolean
+  /**
+   * If this function is provided, it will be called when the pagination state changes and you will be expected to manage the state yourself. You can pass the managed state back to the table via the `tableOptions.state.pagination` option.
+   */
+  onPaginationChange?: OnChangeFn<PaginationState>
+  /**
+   * When manually controlling pagination, you can supply a total `pageCount` value to the table if you know it (Or supply a `rowCount` and `pageCount` will be calculated). If you do not know how many pages there are, you can set this to `-1`.
+   */
+  pageCount?: number
+  /**
+   * When manually controlling pagination, you can supply a total `rowCount` value to the table if you know it. The `pageCount` can be calculated from this value and the `pageSize`.
+   */
+  rowCount?: number
+}
+
+export interface PaginationDefaultOptions {
+  onPaginationChange: OnChangeFn<PaginationState>
+}
+
+export interface Table_RowPagination<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  _autoResetPageIndex: () => void
+  /**
+   * Returns whether the table can go to the next page.
+   */
+  getCanNextPage: () => boolean
+  /**
+   * Returns whether the table can go to the previous page.
+   */
+  getCanPreviousPage: () => boolean
+  /**
+   * Returns the page count. If manually paginating or controlling the pagination state, this will come directly from the `options.pageCount` table option, otherwise it will be calculated from the table data using the total row count and current page size.
+   */
+  getPageCount: () => number
+  /**
+   * Returns the row count. If manually paginating or controlling the pagination state, this will come directly from the `options.rowCount` table option, otherwise it will be calculated from the table data.
+   */
+  getRowCount: () => number
+  /**
+   * Returns an array of page options (zero-index-based) for the current page size.
+   */
+  getPageOptions: () => Array<number>
+  /**
+   * Increments the page index by one, if possible.
+   */
+  nextPage: () => void
+  /**
+   * Decrements the page index by one, if possible.
+   */
+  previousPage: () => void
+  /**
+   * Sets the page index to `0`.
+   */
+  firstPage: () => void
+  /**
+   * Sets the page index to the last page.
+   */
+  lastPage: () => void
+  /**
+   * Resets the page index to its initial state. If `defaultState` is `true`, the page index will be reset to `0` regardless of initial state.
+   */
+  resetPageIndex: (defaultState?: boolean) => void
+  /**
+   * Resets the page size to its initial state. If `defaultState` is `true`, the page size will be reset to `10` regardless of initial state.
+   */
+  resetPageSize: (defaultState?: boolean) => void
+  /**
+   * Resets the **pagination** state to `initialState.pagination`, or `true` can be passed to force a default blank state reset to `[]`.
+   */
+  resetPagination: (defaultState?: boolean) => void
+  /**
+   * Updates the page index using the provided function or value in the `state.pagination.pageIndex` state.
+   */
+  setPageIndex: (updater: Updater<number>) => void
+  /**
+   * Updates the page size using the provided function or value in the `state.pagination.pageSize` state.
+   */
+  setPageSize: (updater: Updater<number>) => void
+  /**
+   * Sets or updates the `state.pagination` state.
+   */
+  setPagination: (updater: Updater<PaginationState>) => void
+}
+
+export interface Table_RowModels_Paginated<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Returns the row model for the table after pagination has been applied.
+   */
+  getPaginatedRowModel: () => RowModel<TFeatures, TData>
+  /**
+   * Returns the row model for the table before any pagination has been applied.
+   */
+  getPrePaginatedRowModel: () => RowModel<TFeatures, TData>
+}
+
+export interface CreateRowModel_Paginated<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Returns the row model after pagination has taken place, but no further.
+   * Pagination columns are automatically reordered by default to the start of the columns list. If you would rather remove them or leave them as-is, set the appropriate mode here.
+   */
+  paginatedRowModel?: (
+    table: Table<TFeatures, TData>,
+  ) => () => RowModel<TFeatures, TData>
+}
+
+export interface CachedRowModel_Paginated<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  paginatedRowModel: () => RowModel<TFeatures, TData>
+}