@tanstack/table-core 8.0.0-alpha.27 → 8.0.0-alpha.32

package/src/utils/paginateRowsFn.ts

@@ -1,28 +0,0 @@
-import { TableInstance, RowModel, AnyGenerics } from '../types'
-import { expandRowsFn } from './expandRowsFn'
-
-export function paginateRowsFn<TGenerics extends AnyGenerics>(
-  instance: TableInstance<TGenerics>,
-  rowModel: RowModel<TGenerics>
-): RowModel<TGenerics> {
-  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,99 +0,0 @@
-import { TableInstance, Row, RowModel, AnyGenerics } from '../types'
-import { SortingFn } from '../features/Sorting'
-
-export function sortRowsFn<TGenerics extends AnyGenerics>(
-  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
-              ? columnInfo.sortUndefined
-              : -columnInfo.sortUndefined
-          }
-        }
-
-        // 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/sortRowsQuicksortFn.ts

@@ -1,174 +0,0 @@
-import { TableInstance, Row, RowModel, AnyGenerics } from '../types'
-import { SortingFn } from '../features/Sorting'
-
-export function sortRowsFn<TGenerics extends AnyGenerics>(
-  instance: TableInstance<TGenerics>,
-  rowModel: RowModel<TGenerics>
-): RowModel<TGenerics> {
-  // window.tanner = []
-
-  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 => {
-      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,
-  }
-}
-
-type Sorter<TGenerics extends AnyGenerics> = {
-  id: string
-  compare: (a: Row<TGenerics>, b: Row<TGenerics>) => number
-  desc?: boolean
-  sortUndefined?: false | -1 | 1
-  invertSorting?: boolean
-}
-
-export function quicksort<TGenerics extends AnyGenerics>(
-  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 (i > 0) {
-          // window.tanner.push([
-          //   sorter.id,
-          //   rowA.values[sorter.id],
-          //   rowB.values[sorter.id],
-          //   sortInt,
-          // ])
-        }
-
-        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
-  }
-}