@tanstack/react-table 8.0.0-alpha.1 → 8.0.0-alpha.11

package/src/filterTypes.ts

@@ -1,251 +0,0 @@
-import { AccessorFn, Row } from './types'
-
-export const filterTypes = {
-  includesString,
-  includesStringSensitive,
-  equalsString,
-  equalsStringSensitive,
-  arrIncludes,
-  arrIncludesAll,
-  equals,
-  weakEquals,
-  betweenNumberRange,
-}
-
-export type BuiltInFilterType = keyof typeof filterTypes
-
-function includesString<
-  TData,
-  TValue,
-  TAccessor extends AccessorFn<TData>,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-  columnIds: string[],
-  filterValue: unknown
-) {
-  const search = String(filterValue).toLowerCase()
-
-  rows = rows.filter(row => {
-    return columnIds.some(id => {
-      return String(row.values[id]).toLowerCase().includes(search)
-    })
-  })
-  return rows
-}
-
-includesString.autoRemove = (val: any) => testFalsey(val)
-
-function includesStringSensitive<
-  TData,
-  TValue,
-  TAccessor extends AccessorFn<TData>,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-  columnIds: string[],
-  filterValue: unknown
-) {
-  const search = String(filterValue)
-
-  rows = rows.filter(row => {
-    return columnIds.some(id => {
-      return String(row.values[id]).includes(search)
-    })
-  })
-  return rows
-}
-
-includesStringSensitive.autoRemove = (val: any) => testFalsey(val)
-
-function equalsString<
-  TData,
-  TValue,
-  TAccessor extends AccessorFn<TData>,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-  columnIds: string[],
-  filterValue: unknown
-) {
-  const search = String(filterValue).toLowerCase()
-
-  return rows.filter(row => {
-    return columnIds.some(id => {
-      const rowValue = row.values[id]
-      return rowValue !== undefined
-        ? String(rowValue).toLowerCase() === search
-        : true
-    })
-  })
-}
-
-equalsString.autoRemove = (val: any) => testFalsey(val)
-
-function equalsStringSensitive<
-  TData,
-  TValue,
-  TAccessor extends AccessorFn<TData>,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-  columnIds: string[],
-  filterValue: unknown
-) {
-  const search = String(filterValue)
-  return rows.filter(row => {
-    return columnIds.some(id => {
-      const rowValue = row.values[id]
-      return rowValue !== undefined ? String(rowValue) === search : true
-    })
-  })
-}
-
-equalsStringSensitive.autoRemove = (val: any) => testFalsey(val)
-
-function arrIncludes<
-  TData,
-  TValue,
-  TAccessor extends AccessorFn<TData>,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-  columnIds: string[],
-  filterValue: unknown
-) {
-  return rows.filter(row => {
-    return columnIds.some(id => {
-      const rowValue = row.values[id]
-      return rowValue.includes(filterValue)
-    })
-  })
-}
-
-arrIncludes.autoRemove = (val: any) => testFalsey(val) || !val?.length
-
-function arrIncludesAll<
-  TData,
-  TValue,
-  TAccessor extends AccessorFn<TData>,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-  columnIds: string[],
-  filterValue: unknown[]
-) {
-  return rows.filter(row => {
-    return columnIds.some(id => {
-      const rowValue = row.values[id]
-      return (
-        rowValue &&
-        rowValue.length &&
-        filterValue.every(val => rowValue.includes(val))
-      )
-    })
-  })
-}
-
-arrIncludesAll.autoRemove = (val: any) => testFalsey(val) || !val?.length
-
-function equals<
-  TData,
-  TValue,
-  TAccessor extends AccessorFn<TData>,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-  columnIds: string[],
-  filterValue: unknown
-) {
-  return rows.filter(row => {
-    return columnIds.some(id => {
-      const rowValue = row.values[id]
-      return rowValue === filterValue
-    })
-  })
-}
-
-equals.autoRemove = (val: any) => testFalsey(val)
-
-function weakEquals<
-  TData,
-  TValue,
-  TAccessor extends AccessorFn<TData>,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-  columnIds: string[],
-  filterValue: unknown
-) {
-  return rows.filter(row => {
-    return columnIds.some(id => {
-      const rowValue = row.values[id]
-      // eslint-disable-next-line eqeqeq
-      return rowValue == filterValue
-    })
-  })
-}
-
-weakEquals.autoRemove = (val: any) => testFalsey(val)
-
-function betweenNumberRange<
-  TData,
-  TValue,
-  TAccessor extends AccessorFn<TData>,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-  columnIds: string[],
-  filterValue: [unknown, unknown]
-) {
-  let [unsafeMin, unsafeMax] = filterValue || []
-
-  let parsedMin =
-    typeof unsafeMin !== 'number' ? parseFloat(unsafeMin as string) : unsafeMin
-  let parsedMax =
-    typeof unsafeMax !== 'number' ? parseFloat(unsafeMax as string) : unsafeMax
-
-  let min =
-    unsafeMin === null || Number.isNaN(parsedMin) ? -Infinity : parsedMin
-  let max = unsafeMax === null || Number.isNaN(parsedMax) ? Infinity : parsedMax
-
-  if (min > max) {
-    const temp = min
-    min = max
-    max = temp
-  }
-
-  return rows.filter(row => {
-    return columnIds.some(id => {
-      const rowValue = row.values[id]
-      return rowValue >= min && rowValue <= max
-    })
-  })
-}
-
-betweenNumberRange.autoRemove = (val: any) =>
-  testFalsey(val) || (testFalsey(val[0]) && testFalsey(val[1]))
-
-// Utils
-
-function testFalsey(val: any) {
-  return val === undefined || val === null || val === ''
-}

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,285 +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'
-
-// 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> &
-  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>
-
-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
-
-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>
-
-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>
-
-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> = {
-  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]