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

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

@@ -1,83 +0,0 @@
-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'
-
-/**
- * Creates a memoized paginated 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.
- */
-export function createPaginatedRowModel<
-  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: '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

@@ -1,95 +0,0 @@
-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 { TableFeature } from '../../types/TableFeatures'
-
-/**
- * Feature that adds pagination state and table APIs for page navigation.
- */
-export const rowPaginationFeature: TableFeature = {
-  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),
-      },
-    })
-  },
-}

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

@@ -1,152 +0,0 @@
-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
-  /**
-   * Called with an updater when pagination state changes. Pair this with
-   * `state.pagination` when using external state; external atoms can own the
-   * slice without this callback.
-   */
-  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
-  /**
-   * Checks whether the current page index can move forward.
-   */
-  getCanNextPage: () => boolean
-  /**
-   * Checks whether the current page index can move backward.
-   */
-  getCanPreviousPage: () => boolean
-  /**
-   * Resolves the current page count from `options.pageCount` or row count and
-   * page size.
-   */
-  getPageCount: () => number
-  /**
-   * Resolves the row count used for pagination math.
-   *
-   * `options.rowCount` wins; otherwise the pre-paginated row model is counted.
-   */
-  getRowCount: () => number
-  /**
-   * Builds zero-based page indexes for the current page count.
-   */
-  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 `pagination.pageIndex` to initial state, or to `0` when
-   * `defaultState` is `true`.
-   */
-  resetPageIndex: (defaultState?: boolean) => void
-  /**
-   * Resets `pagination.pageSize` to initial state, or to `10` when
-   * `defaultState` is `true`.
-   */
-  resetPageSize: (defaultState?: boolean) => void
-  /**
-   * Resets `pagination` to `initialState.pagination`.
-   *
-   * Pass `true` to ignore initial state and reset to
-   * `{ pageIndex: 0, pageSize: 10 }`.
-   */
-  resetPagination: (defaultState?: boolean) => void
-  /**
-   * Updates `pagination.pageIndex` using a value or updater.
-   */
-  setPageIndex: (updater: Updater<number>) => void
-  /**
-   * Updates `pagination.pageSize` using a value or updater.
-   */
-  setPageSize: (updater: Updater<number>) => void
-  /**
-   * Updates pagination state with a next state or updater function.
-   */
-  setPagination: (updater: Updater<PaginationState>) => void
-}
-
-export interface Table_RowModels_Paginated<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * Resolves the row model after pagination has sliced the current page.
-   */
-  getPaginatedRowModel: () => RowModel<TFeatures, TData>
-  /**
-   * Reads the row model immediately before pagination.
-   */
-  getPrePaginatedRowModel: () => RowModel<TFeatures, TData>
-}
-
-export interface CreateRowModel_Paginated<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * Factory used to retrieve the paginated row model. If using server-side
-   * pagination, this is not required. To use client-side pagination, pass
-   * `createPaginatedRowModel()` or implement your own factory.
-   */
-  paginatedRowModel?: (
-    table: Table<TFeatures, TData>,
-  ) => () => RowModel<TFeatures, TData>
-}
-
-export interface CachedRowModel_Paginated<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  paginatedRowModel: () => RowModel<TFeatures, TData>
-}