@tanstack/table-core 8.0.0-alpha.64 → 8.0.0-alpha.68

package/src/utils/getColumnFilteredRowModelAsync.ts

@@ -1,118 +0,0 @@
-import { TableInstance, RowModel, TableGenerics, Row } from '../types'
-import { incrementalMemo } from '../utils'
-
-export function getColumnFilteredRowModelAsync<
-  TGenerics extends TableGenerics
->(opts?: {
-  initialSync?: boolean
-}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
-  return instance =>
-    incrementalMemo(
-      () => [
-        instance.getState().columnFilters,
-        instance.getPreColumnFilteredRowModel(),
-      ],
-      (_sorting, rowModel): RowModel<TGenerics> => {
-        return {
-          rows: rowModel.rows.slice(),
-          flatRows: [],
-          rowsById: rowModel.rowsById,
-        }
-      },
-      (columnFilters, rowModel) => rowModelRef => scheduleTask => {
-        // TODO: Figure out how to do scheduled filtering
-        // 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 || !columnFilters) {
-        //   rowModelRef.current = rowModel
-        // } else {
-        //   const filterFromLeafRows = instance.options.filterFromLeafRows
-
-        //   const filterRows = (
-        //     rowsToFilter: Row<TGenerics>[],
-        //     depth: number
-        //   ) => {
-        //     for (let i = 0; i < columnFilters.length; i++) {
-        //       const { id: columnId, value: filterValue } = columnFilters[i]
-        //       // Find the columnFilters column
-        //       const column = instance.getColumn(columnId)
-
-        //       if (!column) {
-        //         if (process.env.NODE_ENV !== 'production') {
-        //           console.warn(
-        //             `Table: Could not find a column with id: ${columnId}`
-        //           )
-        //         }
-        //         throw new Error()
-        //       }
-
-        //       if (depth === 0) {
-        //         const preFilteredRows = [...rowsToFilter]
-        //         column.getPreFilteredRows = () => preFilteredRows
-        //       }
-
-        //       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}.`
-        //           )
-        //         }
-        //         continue
-        //       }
-
-        //       // Pass the rows, id, filterValue and column to the filterFn
-        //       // to get the filtered rows back
-        //       rowsToFilter = filterFn(rowsToFilter, [columnId], filterValue)
-        //     }
-
-        //     return rowsToFilter
-        //   }
-
-        //   if (filterFromLeafRows) {
-        //     return filterRowModelFromLeafs(rowModel.rows, filterRows, instance)
-        //   }
-
-        //   return filterRowModelFromRoot(rowModel.rows, filterRows, instance)
-        // }
-
-        // // Now that each filtered column has it's partially filtered rows,
-        // // lets assign the final filtered rows to all of the other columns
-        // const nonFilteredColumns = instance
-        //   .getAllLeafColumns()
-        //   .filter(
-        //     column =>
-        //       !instance.getState().columnFilters?.find(d => d.id === column.id)
-        //   )
-
-        // // This essentially enables faceted filter options to be built easily
-        // // using every column's preFilteredRows value
-
-        // nonFilteredColumns.forEach(column => {
-        //   column.getPreFilteredRows = () => rowModelRef.current.rows
-        // })
-      },
-      {
-        key: 'getColumnFilteredRowModelAsync',
-        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/getColumnFilteredRowModelSync.ts

@@ -1,102 +0,0 @@
-import { TableInstance, RowModel, TableGenerics, Row } from '../types'
-import { memo } from '../utils'
-import {
-  filterRowModelFromLeafs,
-  filterRowModelFromRoot,
-} from './filterRowsUtils'
-
-export function getColumnFilteredRowModelSync<
-  TGenerics extends TableGenerics
->(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
-  return instance =>
-    memo(
-      () => [
-        instance.getState().columnFilters,
-        instance.getPreColumnFilteredRowModel(),
-      ],
-      (columnFilters, rowModel) => {
-        const columnFilteredRowModel: RowModel<TGenerics> = (() => {
-          if (!rowModel.rows.length || !columnFilters?.length) {
-            return rowModel
-          }
-
-          const filterFromLeafRows = instance.options.filterFromLeafRows
-
-          const filterRows = (
-            rowsToFilter: Row<TGenerics>[],
-            depth: number
-          ) => {
-            for (let i = 0; i < columnFilters.length; i++) {
-              const { id: columnId, value: filterValue } = columnFilters[i]
-              // Find the columnFilters column
-              const column = instance.getColumn(columnId)
-
-              if (!column) {
-                if (process.env.NODE_ENV !== 'production') {
-                  console.warn(
-                    `Table: Could not find a column with id: ${columnId}`
-                  )
-                }
-                throw new Error()
-              }
-
-              if (depth === 0) {
-                const preFilteredRows = [...rowsToFilter]
-                column.getPreFilteredRows = () => preFilteredRows
-              }
-
-              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}.`
-                  )
-                }
-                continue
-              }
-
-              // Pass the rows, id, filterValue and column to the filterFn
-              // to get the filtered rows back
-              rowsToFilter = filterFn(rowsToFilter, [columnId], filterValue)
-            }
-
-            return rowsToFilter
-          }
-
-          if (filterFromLeafRows) {
-            return filterRowModelFromLeafs(rowModel.rows, filterRows, instance)
-          }
-
-          return filterRowModelFromRoot(rowModel.rows, filterRows, instance)
-        })()
-
-        // Now that each filtered column has it's partially filtered rows,
-        // lets assign the final filtered rows to all of the other columns
-        const nonFilteredColumns = instance
-          .getAllLeafColumns()
-          .filter(
-            column =>
-              !instance.getState().columnFilters?.find(d => d.id === column.id)
-          )
-
-        // This essentially enables faceted filter options to be built easily
-        // using every column's preFilteredRows value
-
-        nonFilteredColumns.forEach(column => {
-          column.getPreFilteredRows = () => columnFilteredRowModel.rows
-        })
-
-        return columnFilteredRowModel
-      },
-      {
-        key: 'getColumnFilteredRowModelSync',
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
-        onChange: () => {
-          instance.queue(() => {
-            instance._autoResetPageIndex()
-          })
-        },
-      }
-    )
-}

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: '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/getGlobalFilteredRowModelAsync.ts

@@ -1,96 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types'
-import { incrementalMemo } from '../utils'
-
-export function getGlobalFilteredRowModelAsync<
-  TGenerics extends TableGenerics
->(opts?: {
-  initialSync?: boolean
-}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
-  return instance =>
-    incrementalMemo(
-      () => [
-        instance.getState().globalFilter,
-        instance.getPreGlobalFilteredRowModel(),
-      ],
-      (_globalFilter, rowModel): RowModel<TGenerics> => {
-        return {
-          rows: rowModel.rows.slice(),
-          flatRows: [],
-          rowsById: rowModel.rowsById,
-        }
-      },
-      (globalFilter, rowModel) => rowModelRef => scheduleTask => {
-        // TODO: Figure out how to do scheduled filtering
-        // 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('')
-
-        // const globalFilteredRowModel: RowModel<TGenerics> = (() => {
-        //   if (!rowModel.rows.length || !globalFilter) {
-        //     return rowModel
-        //   }
-
-        //   const filterFromLeafRows = instance.options.filterFromLeafRows
-
-        //   const filterFn = instance.getGlobalFilterFn()
-
-        //   if (!filterFn) {
-        //     if (process.env.NODE_ENV !== 'production') {
-        //       console.warn(`Could not find a valid 'globalFilterType'`)
-        //     }
-        //     return rowModel
-        //   }
-
-        //   const filterableColumns = instance
-        //     .getAllLeafColumns()
-        //     .filter(column => column.getCanGlobalFilter())
-
-        //   const filterableColumnIds = filterableColumns.map(d => d.id)
-
-        //   const filterRows = (rows: Row<TGenerics>[]) => {
-        //     return filterFn(rows, filterableColumnIds, globalFilter)
-        //   }
-
-        //   if (filterFromLeafRows) {
-        //     return filterRowModelFromLeafs(rowModel.rows, filterRows, instance)
-        //   }
-
-        //   return filterRowModelFromRoot(rowModel.rows, filterRows, instance)
-        // })()
-
-        // // Now that each filtered column has it's partially filtered rows,
-        // // lets assign the final filtered rows to all of the other columns
-        // const nonFilteredColumns = instance
-        //   .getAllLeafColumns()
-        //   .filter(
-        //     column =>
-        //       !instance.getState().columnFilters?.find(d => d.id === column.id)
-        //   )
-
-        // // This essentially enables faceted filter options to be built easily
-        // // using every column's preFilteredRows value
-
-        // nonFilteredColumns.forEach(column => {
-        //   column.getPreFilteredRows = () => globalFilteredRowModel.rows
-        // })
-
-        // return globalFilteredRowModel
-      },
-      {
-        key: 'getGlobalFilteredRowModelAsync',
-        initialSync: opts?.initialSync,
-        onProgress: progress => {
-          instance.setState(old => ({ ...old, globalFilterProgress: progress }))
-        },
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
-        onChange: () => {
-          instance.queue(() => {
-            instance._autoResetPageIndex()
-          })
-        },
-      }
-    )
-}

package/src/utils/getGlobalFilteredRowModelSync.ts

@@ -1,79 +0,0 @@
-import { TableInstance, RowModel, TableGenerics, Row } from '../types'
-import { memo } from '../utils'
-import {
-  filterRowModelFromLeafs,
-  filterRowModelFromRoot,
-} from './filterRowsUtils'
-
-export function getGlobalFilteredRowModelSync<
-  TGenerics extends TableGenerics
->(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics> {
-  return instance =>
-    memo(
-      () => [
-        instance.getState().globalFilter,
-        instance.getPreGlobalFilteredRowModel(),
-      ],
-      (globalFilter, rowModel) => {
-        const globalFilteredRowModel: RowModel<TGenerics> = (() => {
-          if (!rowModel.rows.length || !globalFilter) {
-            return rowModel
-          }
-
-          const filterFromLeafRows = instance.options.filterFromLeafRows
-
-          const filterFn = instance.getGlobalFilterFn()
-
-          if (!filterFn) {
-            if (process.env.NODE_ENV !== 'production') {
-              console.warn(`Could not find a valid 'globalFilterType'`)
-            }
-            return rowModel
-          }
-
-          const filterableColumns = instance
-            .getAllLeafColumns()
-            .filter(column => column.getCanGlobalFilter())
-
-          const filterableColumnIds = filterableColumns.map(d => d.id)
-
-          const filterRows = (rows: Row<TGenerics>[]) => {
-            return filterFn(rows, filterableColumnIds, globalFilter)
-          }
-
-          if (filterFromLeafRows) {
-            return filterRowModelFromLeafs(rowModel.rows, filterRows, instance)
-          }
-
-          return filterRowModelFromRoot(rowModel.rows, filterRows, instance)
-        })()
-
-        // Now that each filtered column has it's partially filtered rows,
-        // lets assign the final filtered rows to all of the other columns
-        const nonFilteredColumns = instance
-          .getAllLeafColumns()
-          .filter(
-            column =>
-              !instance.getState().columnFilters?.find(d => d.id === column.id)
-          )
-
-        // This essentially enables faceted filter options to be built easily
-        // using every column's preFilteredRows value
-
-        nonFilteredColumns.forEach(column => {
-          column.getPreFilteredRows = () => globalFilteredRowModel.rows
-        })
-
-        return globalFilteredRowModel
-      },
-      {
-        key: 'getGlobalFilteredRowModelSync',
-        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: '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
-  }
-}