@tanstack/react-table 8.0.0-alpha.3 → 8.0.0-alpha.30

package/src/types.ts

@@ -1,331 +0,0 @@
-import React from 'react'
-import {
-  CoreColumn,
-  CoreColumnDef,
-  CoreOptions,
-  CoreRow,
-  TableCore,
-} from './core'
-import {
-  VisibilityInstance,
-  VisibilityTableState,
-  VisibilityColumn as ColumnVisibilityColumn,
-  VisibilityOptions,
-  VisibilityColumnDef,
-  VisibilityRow,
-} from './features/Visibility'
-import {
-  ColumnOrderInstance,
-  ColumnOrderOptions,
-  ColumnOrderTableState,
-} from './features/Ordering'
-import {
-  ColumnPinningColumn,
-  ColumnPinningColumnDef,
-  ColumnPinningInstance,
-  ColumnPinningOptions,
-  ColumnPinningTableState,
-} from './features/Pinning'
-import { HeadersInstance, HeadersRow } from './features/Headers'
-import {
-  FiltersColumn,
-  FiltersColumnDef,
-  FiltersInstance,
-  FiltersOptions,
-  FiltersTableState,
-} from './features/Filters'
-import {
-  SortingColumn,
-  SortingColumnDef,
-  SortingInstance,
-  SortingOptions,
-  SortingTableState,
-} from './features/Sorting'
-import {
-  GroupingColumn,
-  GroupingColumnDef,
-  GroupingInstance,
-  GroupingOptions,
-  GroupingRow,
-  GroupingTableState,
-} from './features/Grouping'
-import {
-  ExpandedInstance,
-  ExpandedOptions,
-  ExpandedTableState,
-} from './features/Expanding'
-import { Overwrite } from './utils'
-import {
-  ColumnSizingColumn,
-  ColumnSizingColumnDef,
-  ColumnSizingInstance,
-  ColumnSizingOptions,
-  ColumnSizingTableState,
-} from './features/ColumnSizing'
-import {
-  PaginationInstance,
-  PaginationOptions,
-  PaginationTableState,
-} from './features/Pagination'
-import {
-  RowSelectionInstance,
-  RowSelectionOptions,
-  RowSelectionRow,
-  RowSelectionTableState,
-} from './features/RowSelection'
-
-// declare global {
-//   const process.env.NODE_ENV !== 'production': boolean
-// }
-
-export type ReactTable<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = TableCore<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  VisibilityInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  ColumnOrderInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  ColumnPinningInstance<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  > &
-  HeadersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  FiltersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  SortingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  GroupingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  ColumnSizingInstance<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  > &
-  ExpandedInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  PaginationInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  RowSelectionInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-
-export type Renderable<TProps> =
-  | React.ReactNode
-  | React.FunctionComponent<TProps>
-  | React.Component<TProps>
-
-//
-
-export type Options<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  CoreOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    VisibilityOptions &
-    ColumnOrderOptions &
-    ColumnPinningOptions &
-    FiltersOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    SortingOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    GroupingOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    ExpandedOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    ColumnSizingOptions &
-    PaginationOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    RowSelectionOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-
-export type Updater<T> = T | ((old: T) => T)
-export type OnChangeFn<T> = (updaterOrValue: Updater<T>, value: T) => void
-
-export type TableState = VisibilityTableState &
-  ColumnOrderTableState &
-  ColumnPinningTableState &
-  FiltersTableState &
-  SortingTableState &
-  ExpandedTableState &
-  GroupingTableState &
-  ColumnSizingTableState &
-  PaginationTableState &
-  RowSelectionTableState
-
-export type Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  CoreRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    VisibilityRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    HeadersRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    GroupingRow &
-    RowSelectionRow
-
-export type RowValues = {
-  [key: string]: any
-}
-
-export type RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  {
-    rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-    flatRows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-    rowsById: Record<
-      string,
-      Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-    >
-  }
-
-export type AccessorFn<TData> = (originalRow: TData, index: number) => any
-
-export type ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  CoreColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    VisibilityColumnDef &
-    ColumnPinningColumnDef &
-    FiltersColumnDef<TFilterFns> &
-    SortingColumnDef<TSortingFns> &
-    GroupingColumnDef<TAggregationFns> &
-    ColumnSizingColumnDef
-
-export type Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    CoreColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    ColumnVisibilityColumn &
-    ColumnPinningColumn &
-    FiltersColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    SortingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    GroupingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    ColumnSizingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-
-export type Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
-  id: string
-  rowId: string
-  columnId: string
-  value: TValue
-  row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  getCellProps: PropGetter<CellProps>
-  renderCell: () => React.ReactNode
-}
-
-export type Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  CoreHeader<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-
-export type CoreHeader<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
-  id: string
-  depth: number
-  column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  getWidth: () => number
-  subHeaders: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-  colSpan?: number
-  rowSpan?: number
-  getHeaderProps: PropGetter<HeaderProps>
-  getFooterProps: PropGetter<HeaderProps>
-  getLeafHeaders: () => Header<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  isPlaceholder?: boolean
-  placeholderId?: string
-  renderHeader: (options?: { renderPlaceholder?: boolean }) => React.ReactNode
-  renderFooter: (options?: { renderPlaceholder?: boolean }) => React.ReactNode
-}
-
-export type HeaderGroup<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
-  id: string
-  depth: number
-  headers: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-  getHeaderGroupProps: PropGetter<HeaderGroupProps>
-  getFooterGroupProps: PropGetter<FooterGroupProps>
-}
-
-export type HeaderRenderProps<THeader> = {
-  header: THeader
-}
-
-export type FooterRenderProps<THeader> = {
-  header: THeader
-}
-
-export type CellRenderProps<TCell, TRow> = {
-  cell: TCell
-  row: TRow
-}
-
-export type TableProps = {
-  role: string
-}
-
-export type TableBodyProps = {
-  role: string
-}
-
-export type TableHeadProps = {
-  key: string
-  role: string
-}
-
-export type TableFooterProps = {
-  key: string
-  role: string
-}
-
-export type HeaderGroupProps = {
-  key: string
-  role: string
-}
-
-export type FooterGroupProps = {
-  key: string
-  role: string
-}
-
-export type HeaderProps = {
-  key: string
-  role: string
-  colSpan?: number
-  rowSpan?: number
-}
-
-export type FooterProps = {
-  key: string
-  role: string
-  colSpan?: number
-  rowSpan?: number
-}
-
-export type RowProps = {
-  key: string
-  role: string
-}
-
-export type CellProps = {
-  key: string
-  role: string
-}
-
-export type Listener<TArgs extends [...any]> = (...args: [...TArgs]) => void
-
-//
-
-export type PropGetter<TBase> = <TGetter extends Getter<TBase>>(
-  userProps?: TGetter
-) => PropGetterValue<TBase, TGetter>
-
-export type Getter<TInitial> =
-  | ((initial: TInitial) => object)
-  | object
-  | undefined
-
-export type PropGetterValue<TBase, TGetter> = TGetter extends undefined
-  ? TBase
-  : TGetter extends (...args: any[]) => infer TReturn
-  ? Overwrite<TBase, TReturn>
-  : TGetter extends object
-  ? Overwrite<TBase, TGetter>
-  : never
-
-export type NoInfer<A extends any> = [A][A extends any ? 0 : never]

package/src/utils/columnFilterRowsFn.ts

@@ -1,155 +0,0 @@
-import { ReactTable, Row, RowModel } from '../types'
-
-export function columnFilterRowsFn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
-  const columnFilters = instance.getState().columnFilters
-
-  const newFilteredFlatRows: Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[] = []
-  const newFilteredRowsById: Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  > = {}
-
-  const filterFromChildrenUp = instance.options.filterFromChildrenUp
-
-  const filterRows = (
-    rowsToFilter: Row<
-      TData,
-      TValue,
-      TFilterFns,
-      TSortingFns,
-      TAggregationFns
-    >[],
-    depth: number
-  ) => {
-    columnFilters.forEach(({ id: columnId, value: filterValue }) => {
-      // Find the columnFilters column
-      const column = instance.getColumn(columnId)
-
-      if (!column) {
-        if (process.env.NODE_ENV !== 'production') {
-          console.warn(
-            `React-Table: Could not find a column with id: ${columnId}`
-          )
-        }
-        throw new Error()
-      }
-
-      if (depth === 0) {
-        const preFilteredRows = [...rowsToFilter]
-        column.getPreFilteredRows = () => preFilteredRows
-      }
-
-      const filterFn = instance.getColumnFilterFn(column.id)
-
-      if (!filterFn) {
-        if (process.env.NODE_ENV !== 'production') {
-          console.warn(
-            `Could not find a valid 'column.filterType' for column with the ID: ${column.id}.`
-          )
-        }
-        return
-      }
-
-      // Pass the rows, id, filterValue and column to the filterFn
-      // to get the filtered rows back
-      rowsToFilter = filterFn(rowsToFilter, [columnId], filterValue)
-    })
-
-    return rowsToFilter
-  }
-
-  if (filterFromChildrenUp) {
-    const recurseFilterRows = (
-      rowsToFilter: Row<
-        TData,
-        TValue,
-        TFilterFns,
-        TSortingFns,
-        TAggregationFns
-      >[],
-      depth = 0
-    ) => {
-      // Filter from children up
-      rowsToFilter = rowsToFilter.filter(row => {
-        if (!row.subRows?.length) {
-          return true
-        }
-
-        row.subRows = recurseFilterRows(row.subRows, depth + 1)
-
-        return row.subRows.length
-      })
-
-      rowsToFilter = filterRows(rowsToFilter, depth)
-
-      // Apply the filter to any subRows
-      rowsToFilter.forEach(row => {
-        newFilteredFlatRows.push(row)
-        newFilteredRowsById[row.id] = row
-      })
-
-      return rowsToFilter
-    }
-
-    return {
-      rows: recurseFilterRows(rowModel.rows),
-      flatRows: newFilteredFlatRows,
-      rowsById: newFilteredRowsById,
-    }
-  }
-
-  // Filters top level and nested rows
-  const recurseFilterRows = (
-    rowsToFilter: Row<
-      TData,
-      TValue,
-      TFilterFns,
-      TSortingFns,
-      TAggregationFns
-    >[],
-    depth = 0
-  ) => {
-    // Filter from parents downward
-    rowsToFilter = filterRows(rowsToFilter, depth)
-
-    // Apply the filter to any subRows
-    // We technically could do this recursively in the above loop,
-    // but that would severely hinder the API for the user, since they
-    // would be required to do that recursion in some scenarios
-    rowsToFilter.forEach(row => {
-      newFilteredFlatRows.push(row)
-      newFilteredRowsById[row.id] = row
-
-      if (!filterFromChildrenUp) {
-        if (!row.subRows?.length) {
-          return
-        }
-
-        row.subRows = recurseFilterRows(row.subRows, depth + 1)
-      }
-    })
-
-    return rowsToFilter
-  }
-
-  return {
-    rows: recurseFilterRows(rowModel.rows),
-    flatRows: newFilteredFlatRows,
-    rowsById: newFilteredRowsById,
-  }
-}

package/src/utils/expandRowsFn.ts

@@ -1,50 +0,0 @@
-import { ReactTable, Row, RowModel } from '../types'
-
-export function expandRowsFn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  sortedRowModel: RowModel<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >
-): RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
-  const expandedRows: Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[] = []
-
-  const { expandSubRows } = instance.options
-
-  const handleRow = (
-    row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  ) => {
-    expandedRows.push(row)
-
-    if (
-      expandSubRows &&
-      row.subRows?.length &&
-      instance.getIsRowExpanded(row.id)
-    ) {
-      row.subRows.forEach(handleRow)
-    }
-  }
-
-  sortedRowModel.rows.forEach(handleRow)
-
-  return {
-    rows: expandedRows,
-    flatRows: sortedRowModel.flatRows,
-    rowsById: sortedRowModel.rowsById,
-  }
-}

package/src/utils/globalFilterRowsFn.ts

@@ -1,122 +0,0 @@
-import { ReactTable, Row, RowModel } from '../types'
-
-export function globalFilterRowsFn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
-  const globalFilter = instance.getState().globalFilter
-  const newFilteredFlatRows: Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[] = []
-  const newFilteredRowsById: Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  > = {}
-
-  const filterFromChildrenUp = instance.options.filterFromChildrenUp
-
-  const filterFn = instance.getGlobalFilterFn()
-
-  if (!filterFn) {
-    if (process.env.NODE_ENV !== 'production') {
-      console.warn(`Could not find a valid 'globalFilterType'`)
-    }
-    return rowModel
-  }
-
-  const filterableColumns = instance
-    .getAllLeafColumns()
-    .filter(column => column.getCanGlobalFilter())
-
-  const filterableColumnIds = filterableColumns.map(d => d.id)
-
-  if (filterFromChildrenUp) {
-    const recurseFilterRows = (
-      rowsToFilter: Row<
-        TData,
-        TValue,
-        TFilterFns,
-        TSortingFns,
-        TAggregationFns
-      >[],
-      depth = 0
-    ) => {
-      // Filter from children up
-      rowsToFilter = rowsToFilter.filter(row => {
-        if (!row.subRows?.length) {
-          return true
-        }
-
-        row.subRows = recurseFilterRows(row.subRows, depth + 1)
-
-        return row.subRows.length
-      })
-
-      rowsToFilter = filterFn(rowsToFilter, filterableColumnIds, globalFilter)
-
-      // Apply the filter to any subRows
-      rowsToFilter.forEach(row => {
-        newFilteredFlatRows.push(row)
-        newFilteredRowsById[row.id] = row
-      })
-
-      return rowsToFilter
-    }
-
-    return {
-      rows: recurseFilterRows(rowModel.rows),
-      flatRows: newFilteredFlatRows,
-      rowsById: newFilteredRowsById,
-    }
-  }
-
-  // Filters top level and nested rows
-  const recurseFilterRows = (
-    rowsToFilter: Row<
-      TData,
-      TValue,
-      TFilterFns,
-      TSortingFns,
-      TAggregationFns
-    >[],
-    depth = 0
-  ) => {
-    // Filter from parents downward
-    rowsToFilter = filterFn(rowsToFilter, filterableColumnIds, globalFilter)
-
-    // Apply the filter to any subRows
-    // We technically could do this recursively in the above loop,
-    // but that would severely hinder the API for the user, since they
-    // would be required to do that recursion in some scenarios
-    rowsToFilter.forEach(row => {
-      newFilteredFlatRows.push(row)
-      newFilteredRowsById[row.id] = row
-
-      if (!filterFromChildrenUp) {
-        if (!row.subRows?.length) {
-          return
-        }
-
-        row.subRows = recurseFilterRows(row.subRows, depth + 1)
-      }
-    })
-
-    return rowsToFilter
-  }
-
-  return {
-    rows: recurseFilterRows(rowModel.rows),
-    flatRows: newFilteredFlatRows,
-    rowsById: newFilteredRowsById,
-  }
-}