@tanstack/table-core 8.0.0-alpha.9 → 8.0.0-beta.0

package/src/utils/sortRowsFn.ts

@@ -1,95 +0,0 @@
-import { PartialGenerics, TableInstance, Row, RowModel } from '../types'
-import { SortingFn } from '../features/Sorting'
-
-export function sortRowsFn<TGenerics extends PartialGenerics>(
-  instance: TableInstance<TGenerics>,
-  rowModel: RowModel<TGenerics>
-): RowModel<TGenerics> {
-  const sortingState = instance.getState().sorting
-
-  const sortedFlatRows: Row<TGenerics>[] = []
-
-  // 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<TGenerics>
-    }
-  > = {}
-
-  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<TGenerics>[]) => {
-    // 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,221 +0,0 @@
-import React from 'react'
-import {
-  Getter,
-  NoInfer,
-  PropGetterValue,
-  Renderable,
-  TableState,
-  Updater,
-} 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<T> = (input: T) => T
-
-export function functionalUpdate<T>(updater: Updater<T>, input: T): T {
-  return typeof updater === 'function'
-    ? (updater as DataUpdateFunction<T>)(input)
-    : updater
-}
-
-export function noop() {
-  //
-}
-
-export function makeStateUpdater(key: keyof TableState, instance: unknown) {
-  return (updater: Updater<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?: () => any
-    onChange?: (result: TResult, previousResult?: TResult) => void
-  }
-): () => TResult {
-  let deps: any[] = []
-  let result: TResult | undefined
-
-  return () => {
-    let depTime: number
-    if (opts.key && opts.debug) depTime = performance.now()
-
-    const newDeps = getDeps()
-
-    const depsChanged =
-      newDeps.length !== deps.length ||
-      newDeps.some((dep: any, index: number) => deps[index] !== dep)
-
-    if (depsChanged) {
-      let oldResult = result
-      let resultTime: number
-      if (opts.key && opts.debug) resultTime = performance.now()
-      result = fn(...newDeps)
-      deps = newDeps
-      opts?.onChange?.(result, oldResult)
-
-      if (opts.key && opts.debug) {
-        if (opts?.debug()) {
-          const depEndTime =
-            Math.round((performance.now() - depTime!) * 100) / 100
-          const resultEndTime =
-            Math.round((performance.now() - resultTime!) * 100) / 100
-          const resultFpsPercentage = resultEndTime / 16
-
-          const pad = (str: number | string, num: number) => {
-            str = String(str)
-            while (str.length < num) {
-              str = ' ' + str
-            }
-            return str
-          }
-
-          console.info(
-            `%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`,
-            `
-            font-size: .6rem;
-            font-weight: bold;
-            color: hsl(${Math.max(
-              0,
-              Math.min(120 - 120 * resultFpsPercentage, 120)
-            )}deg 100% 31%);`,
-            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, [a, b]: any) => ({
-                    ...accu,
-                    [a]: b,
-                  }),
-                  {}
-                ),
-              parent,
-            }
-          )
-        }
-      }
-
-      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()
-// }