@tanstack/react-table 8.0.0-alpha.2 → 8.0.0-alpha.22

package/src/sortTypes.ts

@@ -1,159 +0,0 @@
-import { Row } from './types'
-
-const reSplitAlphaNumeric = /([0-9]+)/gm
-
-export const sortTypes = {
-  alphanumeric,
-  alphanumericCaseSensitive,
-  text,
-  textCaseSensitive,
-  datetime,
-  basic,
-}
-
-export type BuiltInSortType = keyof typeof sortTypes
-
-function alphanumeric<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  columnId: string
-) {
-  return compareAlphanumeric(
-    toString(rowA.values[columnId]).toLowerCase(),
-    toString(rowB.values[columnId]).toLowerCase()
-  )
-}
-
-function alphanumericCaseSensitive<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  columnId: string
-) {
-  return compareAlphanumeric(
-    toString(rowA.values[columnId]),
-    toString(rowB.values[columnId])
-  )
-}
-
-// Mixed sorting is slow, but very inclusive of many edge cases.
-// It handles numbers, mixed alphanumeric combinations, and even
-// null, undefined, and Infinity
-function compareAlphanumeric(aStr: string, bStr: string) {
-  // Split on number groups, but keep the delimiter
-  // Then remove falsey split values
-  const a = aStr.split(reSplitAlphaNumeric).filter(Boolean)
-  const b = bStr.split(reSplitAlphaNumeric).filter(Boolean)
-
-  // While
-  while (a.length && b.length) {
-    const aa = a.shift()!
-    const bb = b.shift()!
-
-    const an = parseInt(aa, 10)
-    const bn = parseInt(bb, 10)
-
-    const combo = [an, bn].sort()
-
-    // Both are string
-    if (isNaN(combo[0]!)) {
-      if (aa > bb) {
-        return 1
-      }
-      if (bb > aa) {
-        return -1
-      }
-      continue
-    }
-
-    // One is a string, one is a number
-    if (isNaN(combo[1]!)) {
-      return isNaN(an) ? -1 : 1
-    }
-
-    // Both are numbers
-    if (an > bn) {
-      return 1
-    }
-    if (bn > an) {
-      return -1
-    }
-  }
-
-  return a.length - b.length
-}
-
-// The text filter is more basic (less numeric support)
-// but is much faster
-function text<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  columnId: string
-) {
-  return compareBasic(
-    toString(rowA.values[columnId]).toLowerCase(),
-    toString(rowB.values[columnId]).toLowerCase()
-  )
-}
-
-// The text filter is more basic (less numeric support)
-// but is much faster
-function textCaseSensitive<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  columnId: string
-) {
-  return compareBasic(
-    toString(rowA.values[columnId]),
-    toString(rowB.values[columnId])
-  )
-}
-
-function datetime<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  columnId: string
-) {
-  return compareBasic(
-    (rowA.values[columnId] as Date).getTime(),
-    (rowB.values[columnId] as Date).getTime()
-  )
-}
-
-function basic<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  columnId: string
-) {
-  return compareBasic(rowA.values[columnId], rowB.values[columnId])
-}
-
-// Utils
-
-function compareBasic(a: any, b: any) {
-  return a === b ? 0 : a > b ? 1 : -1
-}
-
-function toString(a: any) {
-  if (typeof a === 'number') {
-    if (isNaN(a) || a === Infinity || a === -Infinity) {
-      return ''
-    }
-    return String(a)
-  }
-  if (typeof a === 'string') {
-    return a
-  }
-  return ''
-}

package/src/types.ts

@@ -1,314 +0,0 @@
-import React from 'react'
-// import * as TS from 'ts-toolbelt'
-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,
-  ColumnSizingHeader,
-  ColumnSizingInstance,
-  ColumnSizingOptions,
-  ColumnSizingTableState,
-} from './features/ColumnSizing'
-
-// 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>
-
-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
-
-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
-
-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
-
-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> &
-    ColumnSizingHeader<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 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,162 +0,0 @@
-import { ReactTable, Row, RowModel } from '../types'
-import { ColumnFiltersState } from '../features/Filters'
-import { Options } from '..'
-
-export const columnFilterRowsFn: Options<
-  any,
-  any,
-  {},
-  {},
-  {}
->['columnFilterRowsFn'] = <
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  columnFilters: ColumnFiltersState,
-  rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> => {
-  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,53 +0,0 @@
-import { ReactTable, Row, RowModel } from '../types'
-import { Options } from '../types'
-import { ExpandedState } from '../features/Expanding'
-
-export const expandRowsFn: Options<any, any, {}, {}, {}>['expandRowsFn'] = <
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  _expandedState: ExpandedState,
-  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,
-  }
-}