@tanstack/react-table 8.0.0-alpha.4 → 8.0.0-alpha.40

package/src/features/Visibility.ts

@@ -1,279 +0,0 @@
-import {
-  Cell,
-  Column,
-  Getter,
-  OnChangeFn,
-  PropGetterValue,
-  ReactTable,
-  Updater,
-} from '../types'
-import { functionalUpdate, makeStateUpdater, memo, propGetter } from '../utils'
-
-export type VisibilityOptions = {
-  onColumnVisibilityChange?: OnChangeFn<VisibilityState>
-  enableHiding?: boolean
-}
-
-export type VisibilityDefaultOptions = {
-  onColumnVisibilityChange: OnChangeFn<VisibilityState>
-}
-
-export type VisibilityState = Record<string, boolean>
-
-export type VisibilityTableState = {
-  columnVisibility: VisibilityState
-}
-
-export type VisibilityInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
-  getVisibleFlatColumns: () => Column<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getVisibleLeafColumns: () => Column<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  setColumnVisibility: (updater: Updater<VisibilityState>) => void
-  toggleColumnVisibility: (columnId: string, value?: boolean) => void
-  toggleAllColumnsVisible: (value?: boolean) => void
-  getColumnIsVisible: (columId: string) => boolean
-  getColumnCanHide: (columnId: string) => boolean
-  getIsAllColumnsVisible: () => boolean
-  getIsSomeColumnsVisible: () => boolean
-  getToggleAllColumnsVisibilityProps: <
-    TGetter extends Getter<ToggleAllColumnsVisibilityProps>
-  >(
-    userProps?: TGetter
-  ) => undefined | PropGetterValue<ToggleAllColumnsVisibilityProps, TGetter>
-}
-
-type ToggleVisibilityProps = {}
-type ToggleAllColumnsVisibilityProps = {}
-
-export type VisibilityColumnDef = {
-  enableHiding?: boolean
-  defaultCanHide?: boolean
-}
-
-export type VisibilityRow<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
-  getVisibleCells: () => Cell<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-}
-
-export type VisibilityColumn = {
-  getCanHide: () => boolean
-  getIsVisible: () => boolean
-  toggleVisibility: (value?: boolean) => void
-  getToggleVisibilityProps: <TGetter extends Getter<ToggleVisibilityProps>>(
-    userProps?: TGetter
-  ) => PropGetterValue<ToggleVisibilityProps, TGetter>
-}
-
-//
-
-export function getInitialState(): VisibilityTableState {
-  return {
-    columnVisibility: {},
-  }
-}
-
-export function getDefaultOptions<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): VisibilityDefaultOptions {
-  return {
-    onColumnVisibilityChange: makeStateUpdater('columnVisibility', instance),
-  }
-}
-
-export function getDefaultColumn() {
-  return {
-    defaultIsVisible: true,
-  }
-}
-
-export function createColumn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): VisibilityColumn {
-  return {
-    getCanHide: () => instance.getColumnCanHide(column.id),
-    getIsVisible: () => instance.getColumnIsVisible(column.id),
-    toggleVisibility: value =>
-      instance.toggleColumnVisibility(column.id, value),
-    getToggleVisibilityProps: userProps => {
-      const props: ToggleVisibilityProps = {
-        type: 'checkbox',
-        checked: column.getIsVisible?.(),
-        title: 'Toggle Column Visibility',
-        onChange: (e: MouseEvent | TouchEvent) => {
-          column.toggleVisibility?.((e.target as HTMLInputElement).checked)
-        },
-      }
-
-      return propGetter(props, userProps)
-    },
-  }
-}
-
-export function getInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): VisibilityInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
-  return {
-    getVisibleFlatColumns: memo(
-      () => [
-        instance.getAllFlatColumns(),
-        instance
-          .getAllFlatColumns()
-          .filter(d => d.getIsVisible?.())
-          .map(d => d.id)
-          .join('_'),
-      ],
-      allFlatColumns => {
-        return allFlatColumns.filter(d => d.getIsVisible?.())
-      },
-      { key: 'getVisibleFlatColumns', debug: instance.options.debug }
-    ),
-
-    getVisibleLeafColumns: memo(
-      () => [
-        instance.getAllLeafColumns(),
-        instance
-          .getAllLeafColumns()
-          .filter(d => d.getIsVisible?.())
-          .map(d => d.id)
-          .join('_'),
-      ],
-      allFlatColumns => {
-        return allFlatColumns.filter(d => d.getIsVisible?.())
-      },
-      { key: 'getVisibleLeafColumns', debug: instance.options.debug }
-    ),
-
-    setColumnVisibility: updater =>
-      instance.options.onColumnVisibilityChange?.(
-        updater,
-        functionalUpdate(updater, instance.getState().columnVisibility)
-      ),
-
-    toggleColumnVisibility: (columnId, value) => {
-      if (!columnId) return
-
-      if (instance.getColumnCanHide(columnId)) {
-        instance.setColumnVisibility(old => ({
-          ...old,
-          [columnId]: value ?? !instance.getColumnIsVisible(columnId),
-        }))
-      }
-    },
-
-    toggleAllColumnsVisible: value => {
-      value = value ?? !instance.getIsAllColumnsVisible()
-
-      instance.setColumnVisibility(
-        instance.getAllLeafColumns().reduce(
-          (obj, column) => ({
-            ...obj,
-            [column.id]: !value ? !column.getCanHide?.() : value,
-          }),
-          {}
-        )
-      )
-    },
-
-    getColumnIsVisible: columnId => {
-      const column = instance.getColumn(columnId)
-
-      if (!column) {
-        throw new Error()
-      }
-
-      return (
-        instance.getState().columnVisibility?.[columnId] ??
-        column.defaultIsVisible ??
-        true
-      )
-    },
-
-    getColumnCanHide: columnId => {
-      const column = instance.getColumn(columnId)
-
-      if (!column) {
-        throw new Error()
-      }
-
-      return (
-        instance.options.enableHiding ??
-        column.enableHiding ??
-        column.defaultCanHide ??
-        true
-      )
-    },
-
-    getIsAllColumnsVisible: () =>
-      !instance.getAllLeafColumns().some(column => !column.getIsVisible?.()),
-
-    getIsSomeColumnsVisible: () =>
-      instance.getAllLeafColumns().some(column => column.getIsVisible?.()),
-
-    getToggleAllColumnsVisibilityProps: userProps => {
-      const props: ToggleAllColumnsVisibilityProps = {
-        onChange: (e: MouseEvent) => {
-          instance.toggleAllColumnsVisible(
-            (e.target as HTMLInputElement)?.checked
-          )
-        },
-        type: 'checkbox',
-        title: 'Toggle visibility for all columns',
-        checked: instance.getIsAllColumnsVisible(),
-        indeterminate:
-          !instance.getIsAllColumnsVisible() &&
-          instance.getIsSomeColumnsVisible()
-            ? 'indeterminate'
-            : undefined,
-      }
-
-      return propGetter(props, userProps)
-    },
-  }
-}

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'
-
-export 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 ''
-}