@tanstack/table-core 8.0.0-alpha.65 → 8.0.0-alpha.69

package/src/utils/getFilteredRowModelSync.ts

@@ -1,150 +0,0 @@
-import { ColumnFilter, FilterFn } from '../features/Filters'
-import { TableInstance, RowModel, TableGenerics, Row } from '../types'
-import { memo } from '../utils'
-import { filterRows } from './filterRowsUtils'
-
-type ResolvedColumnFilter<TGenerics extends TableGenerics> = {
-  id: string
-  filterFn: FilterFn<TGenerics>
-  resolvedFilterValue: unknown
-}
-
-export function getFilteredRowModelSync<TGenerics extends TableGenerics>(): (
-  instance: TableInstance<TGenerics>
-) => () => RowModel<TGenerics> {
-  return instance =>
-    memo(
-      () => [
-        instance.getPreFilteredRowModel(),
-        instance.getState().columnFilters,
-        instance.getState().globalFilter,
-      ],
-      (rowModel, columnFilters, globalFilter) => {
-        const columnFilteredRowModel: RowModel<TGenerics> = (() => {
-          if (
-            !rowModel.rows.length ||
-            (!columnFilters?.length && !globalFilter)
-          ) {
-            return rowModel
-          }
-
-          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 = instance.getColumnFilterFn(column.id)!
-
-            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,
-              resolvedFilterValue:
-                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,
-                resolvedFilterValue:
-                  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.resolvedFilterValue
-                )
-              }
-            }
-
-            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.resolvedFilterValue
-                  )
-                ) {
-                  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)
-        })()
-
-        return columnFilteredRowModel
-      },
-      {
-        key: process.env.NODE_ENV === 'production' && 'getFilteredRowModelSync',
-        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 === 'production' && '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
-  }
-}