@tanstack/table-core 8.0.0-alpha.67 → 8.0.0-alpha.70

package/build/types/utils/getCoreRowModelAsync.d.ts

@@ -1,4 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getCoreRowModelAsync<TGenerics extends TableGenerics>(opts?: {
-    initialSync: boolean;
-}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getFilteredRowModelAsync.d.ts

@@ -1,4 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getFilteredRowModelAsync<TGenerics extends TableGenerics>(opts?: {
-    initialSync?: boolean;
-}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getFilteredRowModelSync.d.ts

@@ -1,2 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getFilteredRowModelSync<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getSortedRowModelAsync.d.ts

@@ -1,13 +0,0 @@
-import { TableInstance, Row, RowModel, TableGenerics } from '../types';
-export declare function getSortedRowModelSync<TGenerics extends TableGenerics>(opts?: {
-    initialSync?: boolean;
-}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
-declare type Sorter<TGenerics extends TableGenerics> = {
-    id: string;
-    compare: (a: Row<TGenerics>, b: Row<TGenerics>) => number;
-    desc?: boolean;
-    sortUndefined?: false | -1 | 1;
-    invertSorting?: boolean;
-};
-export declare function quicksort<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], sorters: Sorter<TGenerics>[]): Row<TGenerics>[];
-export {};

package/build/types/utils/getSortedRowModelSync.d.ts

@@ -1,2 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getSortedRowModelSync<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/src/utils/getCoreRowModelAsync.ts

@@ -1,104 +0,0 @@
-import { TableInstance, Row, RowModel, TableGenerics } from '../types'
-import { getBatchGroups, incrementalMemo } from '../utils'
-
-export function getCoreRowModelAsync<TGenerics extends TableGenerics>(opts?: {
-  initialSync: boolean
-}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
-  return instance =>
-    incrementalMemo(
-      () => [instance.options.data, instance.getAllLeafColumns()],
-      () => {
-        const rows: Row<TGenerics>[] = []
-        const flatRows: Row<TGenerics>[] = []
-        const rowsById: Record<string, Row<TGenerics>> = {}
-
-        return { rows, flatRows, rowsById }
-      },
-      (data, leafColumns) => rowModelRef => scheduleTask => {
-        const accessRows = (
-          originalRows: TGenerics['Row'][],
-          depth = 0,
-          parent?: Row<TGenerics>
-        ) => {
-          const batchGroups = getBatchGroups(originalRows, 2000)
-
-          for (let i = 0; i < batchGroups.length; i++) {
-            const batchGroup = batchGroups[i]
-            scheduleTask(() => {
-              for (let i = 0; i < batchGroup.items.length; i++) {
-                const originalRow = batchGroup.items[i]
-                const rowIndex = batchGroup.start + i
-                const id = instance.getRowId(originalRow, rowIndex, parent)
-
-                if (!id) {
-                  if (process.env.NODE_ENV !== 'production') {
-                    throw new Error(`getRowId expected an ID, but got ${id}`)
-                  }
-                }
-
-                const values: Record<string, any> = {}
-
-                for (let i = 0; i < leafColumns.length; i++) {
-                  const column = leafColumns[i]
-                  if (column && column.accessorFn) {
-                    values[column.id] = column.accessorFn(originalRow, rowIndex)
-                  }
-                }
-
-                // Make the row
-                const row = instance.createRow(
-                  id,
-                  originalRow,
-                  rowIndex,
-                  depth,
-                  values
-                )
-
-                // Push instance row into the parentRows array
-                if (parent) {
-                  parent.subRows.push(row)
-                } else {
-                  rowModelRef.current.rows.push(row)
-                }
-                // Keep track of every row in a flat array
-                rowModelRef.current.flatRows.push(row)
-                // Also keep track of every row by its ID
-                rowModelRef.current.rowsById[id] = row
-
-                // Get the original subrows
-                if (instance.options.getSubRows) {
-                  const originalSubRows = instance.options.getSubRows(
-                    originalRow,
-                    rowIndex
-                  )
-
-                  // Then recursively access them
-                  if (originalSubRows?.length) {
-                    row.originalSubRows = originalSubRows
-                    row.subRows = []
-
-                    accessRows(row.originalSubRows, depth + 1, row)
-                  }
-                }
-              }
-            })
-          }
-        }
-
-        accessRows(data)
-      },
-      {
-        key: process.env.NODE_ENV === 'development' && 'getRowModel',
-        initialSync: opts?.initialSync,
-        onProgress: progress => {
-          instance.setState(old => ({ ...old, coreProgress: progress }))
-        },
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
-        onChange: () => {
-          instance.queue(() => {
-            instance._autoResetPageIndex()
-          })
-        },
-      }
-    )
-}

package/src/utils/getFilteredRowModelAsync.ts

@@ -1,157 +0,0 @@
-import { ResolvedColumnFilter } from '../features/Filters'
-import { TableInstance, RowModel, TableGenerics, Row } from '../types'
-import { incrementalMemo } from '../utils'
-import { filterRows } from './filterRowsUtils'
-
-export function getFilteredRowModelAsync<
-  TGenerics extends TableGenerics
->(opts?: {
-  initialSync?: boolean
-}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
-  return instance =>
-    incrementalMemo(
-      () => [
-        instance.getPreFilteredRowModel(),
-        instance.getState().columnFilters,
-        instance.getState().globalFilter,
-      ],
-      (rowModel): RowModel<TGenerics> => {
-        return {
-          rows: rowModel.rows.slice(),
-          flatRows: [],
-          rowsById: rowModel.rowsById,
-        }
-      },
-      (rowModel, columnFilters, globalFilter) => rowModelRef => scheduleTask => {
-        if (
-          !rowModel.rows.length ||
-          (!columnFilters?.length && !globalFilter)
-        ) {
-          rowModelRef.current = rowModel
-          return
-        }
-
-        const resolvedColumnFilters: ResolvedColumnFilter<TGenerics>[] = []
-        const resolvedGlobalFilters: ResolvedColumnFilter<TGenerics>[] = []
-
-        ;(columnFilters ?? []).forEach(d => {
-          const column = instance.getColumn(d.id)
-
-          if (!column) {
-            if (process.env.NODE_ENV !== 'production') {
-              console.warn(
-                `Table: Could not find a column to filter with columnId: ${d.id}`
-              )
-            }
-          }
-
-          const filterFn = column.getFilterFn()!
-
-          if (!filterFn) {
-            if (process.env.NODE_ENV !== 'production') {
-              console.warn(
-                `Could not find a valid 'column.filterFn' for column with the ID: ${column.id}.`
-              )
-            }
-            return
-          }
-
-          resolvedColumnFilters.push({
-            id: d.id,
-            filterFn,
-            resolvedValue: filterFn.resolveFilterValue?.(d.value) ?? d.value,
-          })
-        })
-
-        const filterableIds = columnFilters.map(d => d.id)
-
-        const globalFilterFn = instance.getGlobalFilterFn()
-
-        const globallyFilterableColumns = instance
-          .getAllLeafColumns()
-          .filter(column => column.getCanGlobalFilter())
-
-        if (
-          globalFilter &&
-          globalFilterFn &&
-          globallyFilterableColumns.length
-        ) {
-          filterableIds.push('__global__')
-
-          globallyFilterableColumns.forEach(column => {
-            resolvedGlobalFilters.push({
-              id: column.id,
-              filterFn: globalFilterFn,
-              resolvedValue:
-                globalFilterFn.resolveFilterValue?.(globalFilter) ??
-                globalFilter,
-            })
-          })
-        }
-
-        // Flag the prefiltered row model with each filter state
-        for (let j = 0; j < rowModel.flatRows.length; j++) {
-          const row = rowModel.flatRows[j]
-
-          row.columnFilterMap = {}
-
-          if (resolvedColumnFilters.length) {
-            for (let i = 0; i < resolvedColumnFilters.length; i++) {
-              const columnFilter = resolvedColumnFilters[i]
-
-              // Tag the row with the column filter state
-              row.columnFilterMap[columnFilter.id] = columnFilter.filterFn(
-                row,
-                columnFilter.id,
-                columnFilter.resolvedValue
-              )
-            }
-          }
-
-          if (resolvedGlobalFilters.length) {
-            let hit = false
-
-            for (let i = 0; i < resolvedGlobalFilters.length; i++) {
-              const globalFilter = resolvedGlobalFilters[i]
-              // Tag the row with the first truthy global filter state
-              if (
-                globalFilter.filterFn(
-                  row,
-                  globalFilter.id,
-                  globalFilter.resolvedValue
-                )
-              ) {
-                hit = true
-                row.columnFilterMap.__global__ = true
-                break
-              }
-            }
-
-            if (row.columnFilterMap.__global__ !== true) {
-              row.columnFilterMap.__global__ = false
-            }
-          }
-        }
-
-        // Filter final rows using all of the active filters
-        return filterRows(rowModel.rows, filterableIds, instance)
-      },
-      {
-        key:
-          process.env.NODE_ENV === 'production' && 'getFilteredRowModelAsync',
-        initialSync: opts?.initialSync,
-        onProgress: progress => {
-          instance.setState(old => ({
-            ...old,
-            columnFiltersProgress: progress,
-          }))
-        },
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
-        onChange: () => {
-          instance.queue(() => {
-            instance._autoResetPageIndex()
-          })
-        },
-      }
-    )
-}

package/src/utils/getSortedRowModelAsync.ts

@@ -1,200 +0,0 @@
-import { TableInstance, Row, RowModel, TableGenerics } from '../types'
-import { incrementalMemo, memo } from '../utils'
-
-export function getSortedRowModelSync<TGenerics extends TableGenerics>(opts?: {
-  initialSync?: boolean
-}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
-  return instance =>
-    incrementalMemo(
-      () => [instance.getState().sorting, instance.getPreSortedRowModel()],
-      (_sorting, rowModel): RowModel<TGenerics> => {
-        return {
-          rows: rowModel.rows.slice(),
-          flatRows: [],
-          rowsById: rowModel.rowsById,
-        }
-      },
-      (sorting, rowModel) => rowModelRef => scheduleTask => {
-        // TODO: Figure out how to do async sorting
-        // We probably need to use a sorting algo that is "divide and
-        // conquer", since that will probably distribute the easiest into
-        // separate tasks.  The trick will be batching those tasks in a way
-        // that makes them fast. JS work loops don't tend to do well with
-        // a high number of tasks that do one thing. Instead, shoot for each
-        // task to have a few thousand opts (or whatever amount is generally
-        // fast for most devices).
-
-        throw new Error()
-
-        // if (!rowModel.rows.length || !sorting?.length) {
-        //   rowModelRef.current = rowModel
-        //   return
-        // }
-
-        // 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 sorters = availableSorting.map(columnSorting => {
-        //   const column = instance.getColumn(columnSorting.id)!
-        //   const sortingFn = instance.getColumnSortingFn(columnSorting.id)!
-
-        //   return {
-        //     id: columnSorting.id,
-        //     compare: (rowA: Row<TGenerics>, rowB: Row<TGenerics>) =>
-        //       sortingFn(rowA, rowB, columnSorting.id),
-        //     desc: columnSorting.desc,
-        //     invertSorting: column.invertSorting,
-        //     sortUndefined: column.sortUndefined,
-        //   }
-        // })
-
-        // const sortData = (rows: Row<TGenerics>[]) => {
-        //   // This will also perform a stable sorting using the row index
-        //   // if needed.
-
-        //   const sortedData = quicksort(rows, sorters)
-
-        //   // If there are sub-rows, sort them
-        //   sortedData.forEach(row => {
-        //     rowModelRef.current.flatRows.push(row)
-        //     if (!row.subRows || row.subRows.length <= 1) {
-        //       return
-        //     }
-        //     row.subRows = sortData(row.subRows)
-        //   })
-
-        //   return sortedData
-        // }
-
-        // sortData(rowModelRef.current.rows)
-      },
-      {
-        key: process.env.NODE_ENV === 'development' && 'getSortedRowModel',
-        initialSync: opts?.initialSync,
-        onProgress: progress => {
-          instance.setState(old => ({ ...old, sortingProgress: progress }))
-        },
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
-        onChange: () => {
-          instance.queue(() => {
-            instance._autoResetPageIndex()
-          })
-        },
-      }
-    )
-}
-
-type Sorter<TGenerics extends TableGenerics> = {
-  id: string
-  compare: (a: Row<TGenerics>, b: Row<TGenerics>) => number
-  desc?: boolean
-  sortUndefined?: false | -1 | 1
-  invertSorting?: boolean
-}
-
-export function quicksort<TGenerics extends TableGenerics>(
-  rows: Row<TGenerics>[],
-  sorters: Sorter<TGenerics>[]
-): Row<TGenerics>[] {
-  if (!rows.length) {
-    return rows
-  }
-
-  // Copy the rows so we can mutate the order
-  rows = rows.slice()
-
-  // Start the quicksort recursion
-  recurse(0, rows.length - 1)
-
-  // Return the rows
-  return rows
-
-  function recurse(start: number, end: number) {
-    const pivotIndex = pivot(start, end)
-
-    if (start < pivotIndex - 1) {
-      recurse(start, pivotIndex - 1)
-    }
-
-    if (pivotIndex < end) {
-      recurse(pivotIndex + 1, end)
-    }
-  }
-
-  function pivot(start: number, end: number) {
-    const pivotIndex = Math.floor((start + end) / 2)
-    let i = start
-    let j = end
-
-    const compare = (a: number, b: number) => {
-      const rowA = rows[a]
-      const rowB = rows[b]
-
-      for (let i = 0; i < sorters.length; i += 1) {
-        const sorter = sorters[i]!
-        const isDesc = sorter?.desc ?? false
-
-        if (sorter.sortUndefined) {
-          const aValue = rowA.values[sorter.id]
-          const bValue = rowB.values[sorter.id]
-
-          const aUndefined = typeof aValue === 'undefined'
-          const bUndefined = typeof bValue === 'undefined'
-
-          if (aUndefined || bUndefined) {
-            if (aUndefined !== bUndefined) {
-              return aUndefined ? sorter.sortUndefined : -sorter.sortUndefined
-            }
-          }
-        }
-
-        // This function should always return in ascending order
-        let sortInt = sorter.compare(rowA, rowB)
-
-        if (sortInt !== 0) {
-          if (isDesc) {
-            sortInt *= -1
-          }
-
-          if (sorter.invertSorting) {
-            sortInt *= -1
-          }
-
-          return sortInt
-        }
-      }
-
-      return rowA.index < rowB.index ? -1 : 1
-    }
-
-    while (i <= j) {
-      while (compare(i, pivotIndex) < 0) {
-        i++
-      }
-
-      while (compare(pivotIndex, j) < 0) {
-        j--
-      }
-
-      if (i <= j) {
-        swap(rows, i, j)
-        i++
-        j--
-      }
-    }
-
-    return i
-  }
-
-  function swap<T>(arr: T[], a: number, b: number) {
-    const t = arr[a]
-    arr[a] = arr[b]
-    arr[b] = t
-  }
-}