@tanstack/react-table 8.0.0-alpha.7 → 8.0.0-alpha.70

package/src/utils/groupRowsFn.ts

@@ -1,194 +0,0 @@
-import { ReactTable, Row, RowModel } from '../types'
-import { flattenBy } from '../utils'
-
-export function groupRowsFn<
-  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 groupingState = instance.getState().grouping
-  // Filter the grouping list down to columns that exist
-  const existingGrouping = groupingState.filter(columnId =>
-    instance.getColumn(columnId)
-  )
-
-  // Find the columns that can or are aggregating
-  // Uses each column to aggregate rows into a single value
-  const aggregateRowsToValues = (
-    leafRows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-    groupedRows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-    depth: number
-  ) => {
-    const values: Record<string, unknown> = {}
-
-    instance.getAllLeafColumns().forEach(column => {
-      // Don't aggregate columns that are in the grouping
-      if (existingGrouping.includes(column.id)) {
-        values[column.id] = groupedRows[0]
-          ? groupedRows[0].values[column.id]
-          : null
-        return
-      }
-
-      // Aggregate the values
-      const aggregateFn = instance.getColumnAggregationFn(column.id)
-
-      if (aggregateFn) {
-        // Get the columnValues to aggregate
-        const groupedValues = groupedRows.map(row => row.values[column.id])
-
-        // Get the columnValues to aggregate
-        const leafValues = leafRows.map(row => {
-          let columnValue = row.values[column.id]
-
-          if (!depth && column.aggregateValue) {
-            columnValue = column.aggregateValue(columnValue)
-          }
-
-          return columnValue
-        })
-
-        values[column.id] = aggregateFn(leafValues, groupedValues)
-      } else if (column.aggregationType) {
-        console.info({ column })
-        throw new Error(
-          process.env.NODE_ENV !== 'production'
-            ? `React Table: Invalid column.aggregateType option for column listed above`
-            : ''
-        )
-      } else {
-        values[column.id] = null
-      }
-    })
-
-    return values
-  }
-
-  const groupedFlatRows: Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[] = []
-  const groupedRowsById: Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  > = {}
-  // const onlyGroupedFlatRows: Row[] = [];
-  // const onlyGroupedRowsById: Record<RowId, Row> = {};
-  // const nonGroupedFlatRows: Row[] = [];
-  // const nonGroupedRowsById: Record<RowId, Row> = {};
-
-  // Recursively group the data
-  const groupUpRecursively = (
-    rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-    depth = 0,
-    parentId: string
-  ) => {
-    // This is the last level, just return the rows
-    if (depth === existingGrouping.length) {
-      return rows
-    }
-
-    const columnId = existingGrouping[depth]!
-
-    // Group the rows together for this level
-    const rowGroupsMap = groupBy(rows, columnId)
-
-    // Peform aggregations for each group
-    const aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map(
-      ([groupingValue, groupedRows], index) => {
-        let id = `${columnId}:${groupingValue}`
-        id = parentId ? `${parentId}>${id}` : id
-
-        // First, Recurse to group sub rows before aggregation
-        const subRows = groupUpRecursively(groupedRows, depth + 1, id)
-
-        // Flatten the leaf rows of the rows in this group
-        const leafRows = depth
-          ? flattenBy(groupedRows, row => row.leafRows)
-          : groupedRows
-
-        const values = aggregateRowsToValues(leafRows, groupedRows, depth)
-
-        const row = instance.createRow(id, undefined, index, depth, values)
-
-        Object.assign(row, {
-          groupingColumnId: columnId,
-          groupingValue,
-          subRows,
-          leafRows,
-        })
-
-        subRows.forEach(subRow => {
-          groupedFlatRows.push(subRow)
-          groupedRowsById[subRow.id] = subRow
-          // if (subRow.getIsGrouped?.()) {
-          //   onlyGroupedFlatRows.push(subRow);
-          //   onlyGroupedRowsById[subRow.id] = subRow;
-          // } else {
-          //   nonGroupedFlatRows.push(subRow);
-          //   nonGroupedRowsById[subRow.id] = subRow;
-          // }
-        })
-
-        return row
-      }
-    )
-
-    return aggregatedGroupedRows
-  }
-
-  const groupedRows = groupUpRecursively(sortedRowModel.rows, 0, '')
-
-  groupedRows.forEach(subRow => {
-    groupedFlatRows.push(subRow)
-    groupedRowsById[subRow.id] = subRow
-    // if (subRow.getIsGrouped?.()) {
-    //   onlyGroupedFlatRows.push(subRow);
-    //   onlyGroupedRowsById[subRow.id] = subRow;
-    // } else {
-    //   nonGroupedFlatRows.push(subRow);
-    //   nonGroupedRowsById[subRow.id] = subRow;
-    // }
-  })
-
-  return {
-    rows: groupedRows,
-    flatRows: groupedFlatRows,
-    rowsById: groupedRowsById,
-  }
-}
-
-function groupBy<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-  columnId: string
-) {
-  const groupMap = new Map<
-    any,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-  >()
-
-  return rows.reduce((map, row) => {
-    const resKey = `${row.values[columnId]}`
-    const previous = map.get(resKey)
-    if (!previous) {
-      map.set(resKey, [row])
-    } else {
-      map.set(resKey, [...previous, row])
-    }
-    return map
-  }, groupMap)
-}

package/src/utils/paginateRowsFn.ts

@@ -1,34 +0,0 @@
-import { ReactTable, RowModel } from '../types'
-import { expandRowsFn } from './expandRowsFn'
-
-export function paginateRowsFn<
-  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 { pageSize, pageIndex } = instance.getState().pagination
-  let { rows, flatRows, rowsById } = rowModel
-  const pageStart = pageSize * pageIndex
-  const pageEnd = pageStart + pageSize
-
-  rows = rows.slice(pageStart, pageEnd)
-
-  if (!instance.options.paginateExpandedRows) {
-    return expandRowsFn(instance, {
-      rows,
-      flatRows,
-      rowsById,
-    })
-  }
-
-  return {
-    rows,
-    flatRows,
-    rowsById,
-  }
-}

package/src/utils/sortRowsFn.ts

@@ -1,115 +0,0 @@
-import { ReactTable, Row, RowModel } from '../types'
-import { SortingFn } from '../features/Sorting'
-
-export function sortRowsFn<
-  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 sortingState = instance.getState().sorting
-
-  const sortedFlatRows: Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[] = []
-
-  // Filter out sortings that correspond to non existing columns
-  const availableSorting = sortingState.filter(sort =>
-    instance.getColumnCanSort(sort.id)
-  )
-
-  const columnInfoById: Record<
-    string,
-    {
-      sortUndefined?: false | -1 | 1
-      invertSorting?: boolean
-      sortingFn: SortingFn<
-        TData,
-        TValue,
-        TFilterFns,
-        TSortingFns,
-        TAggregationFns
-      >
-    }
-  > = {}
-
-  availableSorting.forEach(sortEntry => {
-    const column = instance.getColumn(sortEntry.id)!
-
-    columnInfoById[sortEntry.id] = {
-      sortUndefined: column.sortUndefined,
-      invertSorting: column.invertSorting,
-      sortingFn: instance.getColumnSortingFn(sortEntry.id)!,
-    }
-  })
-
-  const sortData = (
-    rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-  ) => {
-    // This will also perform a stable sorting using the row index
-    // if needed.
-    const sortedData = rows.slice()
-
-    sortedData.sort((rowA, rowB) => {
-      for (let i = 0; i < availableSorting.length; i += 1) {
-        const sortEntry = availableSorting[i]!
-        const columnInfo = columnInfoById[sortEntry.id]!
-        const isDesc = sortEntry?.desc ?? false
-
-        if (columnInfo.sortUndefined) {
-          const aValue = rowA.values[sortEntry.id]
-          const bValue = rowB.values[sortEntry.id]
-
-          const aUndefined = typeof aValue === 'undefined'
-          const bUndefined = typeof bValue === 'undefined'
-
-          if (aUndefined || bUndefined) {
-            return aUndefined && bUndefined ? 0 : aUndefined ? 1 : -1
-          }
-        }
-
-        // This function should always return in ascending order
-        let sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id)
-
-        if (sortInt !== 0) {
-          if (isDesc) {
-            sortInt *= -1
-          }
-
-          if (columnInfo.invertSorting) {
-            sortInt *= -1
-          }
-
-          return sortInt
-        }
-      }
-
-      return rowA.index - rowB.index
-    })
-
-    // If there are sub-rows, sort them
-    sortedData.forEach(row => {
-      sortedFlatRows.push(row)
-      if (!row.subRows || row.subRows.length <= 1) {
-        return
-      }
-      row.subRows = sortData(row.subRows)
-    })
-
-    return sortedData
-  }
-
-  return {
-    rows: sortData(rowModel.rows),
-    flatRows: sortedFlatRows,
-    rowsById: rowModel.rowsById,
-  }
-}

package/src/utils.tsx

@@ -1,195 +0,0 @@
-import React from 'react'
-import {
-  Getter,
-  NoInfer,
-  PropGetterValue,
-  Renderable,
-  TableState,
-} from './types'
-
-export type IsAny<T> = 0 extends 1 & T ? true : false
-export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
-export type RequiredKeys<T, K extends keyof T> = Omit<T, K> &
-  Required<Pick<T, K>>
-export type Overwrite<T, U> = Omit<T, keyof U> & U
-
-export type DataUpdateFunction<TInput, TOutput> = (input: TInput) => TOutput
-
-export type Updater<TInput, TOutput> =
-  | TOutput
-  | DataUpdateFunction<TInput, TOutput>
-
-export function functionalUpdate<TInput, TOutput = TInput>(
-  updater: Updater<TInput, TOutput>,
-  input: TInput
-): TOutput {
-  return typeof updater === 'function'
-    ? (updater as DataUpdateFunction<TInput, TOutput>)(input)
-    : updater
-}
-
-export function noop() {
-  //
-}
-
-export function makeStateUpdater(key: keyof TableState, instance: unknown) {
-  return (updater: Updater<any, any>) => {
-    ;(instance as any).setState(<TTableState,>(old: TTableState) => {
-      return {
-        ...old,
-        [key]: functionalUpdate(updater, (old as any)[key]),
-      }
-    })
-  }
-}
-
-type AnyFunction = (...args: any) => any
-
-export function isFunction<T extends AnyFunction>(d: any): d is T {
-  return d instanceof Function
-}
-
-export function flattenBy<TNode>(
-  arr: TNode[],
-  getChildren: (item: TNode) => TNode[]
-) {
-  const flat: TNode[] = []
-
-  const recurse = (subArr: TNode[]) => {
-    subArr.forEach(item => {
-      flat.push(item)
-      const children = getChildren(item)
-      if (children?.length) {
-        recurse(children)
-      }
-    })
-  }
-
-  recurse(arr)
-
-  return flat
-}
-
-type PropGetterImpl = <TBaseProps, TGetter extends Getter<TBaseProps>>(
-  initial: TBaseProps,
-  userProps?: TGetter
-) => PropGetterValue<TBaseProps, TGetter>
-
-// @ts-ignore // Just rely on the type, not the implementation
-export const propGetter: PropGetterImpl = (initial, getter) => {
-  if (isFunction(getter)) {
-    return getter(initial)
-  }
-
-  return {
-    ...initial,
-    ...(getter ?? {}),
-  }
-}
-
-export function memo<TDeps extends readonly any[], TResult>(
-  getDeps: () => [...TDeps],
-  fn: (...args: NoInfer<[...TDeps]>) => TResult,
-  opts: {
-    key: string
-    debug?: boolean
-    onChange?: (result: TResult, previousResult?: TResult) => void
-  }
-): () => TResult {
-  let deps: any[] = []
-  let result: TResult | undefined
-
-  return () => {
-    const newDeps = getDeps()
-
-    const depsChanged =
-      newDeps.length !== deps.length ||
-      newDeps.some((dep: any, index: number) => deps[index] !== dep)
-
-    if (depsChanged) {
-      if (opts?.debug) {
-        console.info(opts?.key, {
-          length: `${deps.length} -> ${newDeps.length}`,
-          ...newDeps
-            .map((_, index) => {
-              if (deps[index] !== newDeps[index]) {
-                return [index, deps[index], newDeps[index]]
-              }
-
-              return false
-            })
-            .filter(Boolean)
-            .reduce(
-              (accu, curr: any) => ({
-                ...accu,
-                [curr[0]]: curr.slice(1),
-              }),
-              {}
-            ),
-          parent,
-        })
-      }
-
-      let oldResult = result
-      result = fn(...newDeps)
-      deps = newDeps
-      opts?.onChange?.(result, oldResult)
-
-      oldResult = undefined
-    }
-
-    return result!
-  }
-}
-
-export type Render = typeof flexRender
-
-export function flexRender<TProps extends {}>(
-  Comp: Renderable<TProps>,
-  props: TProps
-): React.ReactNode {
-  return !Comp ? null : isReactComponent(Comp) ? <Comp {...props} /> : Comp
-}
-
-function isReactComponent(component: unknown): component is React.FC {
-  return (
-    isClassComponent(component) ||
-    typeof component === 'function' ||
-    isExoticComponent(component)
-  )
-}
-
-function isClassComponent(component: any) {
-  return (
-    typeof component === 'function' &&
-    (() => {
-      const proto = Object.getPrototypeOf(component)
-      return proto.prototype && proto.prototype.isReactComponent
-    })()
-  )
-}
-
-function isExoticComponent(component: any) {
-  return (
-    typeof component === 'object' &&
-    typeof component.$$typeof === 'symbol' &&
-    ['react.memo', 'react.forward_ref'].includes(component.$$typeof.description)
-  )
-}
-
-// export function hashString(str: string, seed = 0): string {
-//   let h1 = 0xdeadbeef ^ seed,
-//     h2 = 0x41c6ce57 ^ seed
-//   for (let i = 0, ch; i < str.length; i++) {
-//     ch = str.charCodeAt(i)
-//     h1 = Math.imul(h1 ^ ch, 2654435761)
-//     h2 = Math.imul(h2 ^ ch, 1597334677)
-//   }
-//   h1 =
-//     Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^
-//     Math.imul(h2 ^ (h2 >>> 13), 3266489909)
-//   h2 =
-//     Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^
-//     Math.imul(h1 ^ (h1 >>> 13), 3266489909)
-//   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString()
-// }