@tanstack/react-table 8.0.0-alpha.9 → 8.0.0-beta.2

package/src/utils/columnFilterRowsFn.ts

@@ -1,113 +0,0 @@
-import { PartialGenerics, TableInstance, Row, RowModel } from '../types'
-
-export function columnFilterRowsFn<TGenerics extends PartialGenerics>(
-  instance: TableInstance<TGenerics>,
-  rowModel: RowModel<TGenerics>
-): RowModel<TGenerics> {
-  const columnFilters = instance.getState().columnFilters
-
-  const newFilteredFlatRows: Row<TGenerics>[] = []
-  const newFilteredRowsById: Record<string, Row<TGenerics>> = {}
-
-  const filterFromChildrenUp = instance.options.filterFromChildrenUp
-
-  const filterRows = (rowsToFilter: Row<TGenerics>[], depth: number) => {
-    columnFilters.forEach(({ id: columnId, value: filterValue }) => {
-      // Find the columnFilters column
-      const column = instance.getColumn(columnId)
-
-      if (!column) {
-        if (process.env.NODE_ENV !== 'production') {
-          console.warn(
-            `React-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.filterType' for column with the ID: ${column.id}.`
-          )
-        }
-        return
-      }
-
-      // Pass the rows, id, filterValue and column to the filterFn
-      // to get the filtered rows back
-      rowsToFilter = filterFn(rowsToFilter, [columnId], filterValue)
-    })
-
-    return rowsToFilter
-  }
-
-  if (filterFromChildrenUp) {
-    const recurseFilterRows = (rowsToFilter: Row<TGenerics>[], depth = 0) => {
-      // Filter from children up
-      rowsToFilter = rowsToFilter.filter(row => {
-        if (!row.subRows?.length) {
-          return true
-        }
-
-        row.subRows = recurseFilterRows(row.subRows, depth + 1)
-
-        return row.subRows.length
-      })
-
-      rowsToFilter = filterRows(rowsToFilter, depth)
-
-      // Apply the filter to any subRows
-      rowsToFilter.forEach(row => {
-        newFilteredFlatRows.push(row)
-        newFilteredRowsById[row.id] = row
-      })
-
-      return rowsToFilter
-    }
-
-    return {
-      rows: recurseFilterRows(rowModel.rows),
-      flatRows: newFilteredFlatRows,
-      rowsById: newFilteredRowsById,
-    }
-  }
-
-  // Filters top level and nested rows
-  const recurseFilterRows = (rowsToFilter: Row<TGenerics>[], depth = 0) => {
-    // Filter from parents downward
-    rowsToFilter = filterRows(rowsToFilter, depth)
-
-    // Apply the filter to any subRows
-    // We technically could do this recursively in the above loop,
-    // but that would severely hinder the API for the user, since they
-    // would be required to do that recursion in some scenarios
-    rowsToFilter.forEach(row => {
-      newFilteredFlatRows.push(row)
-      newFilteredRowsById[row.id] = row
-
-      if (!filterFromChildrenUp) {
-        if (!row.subRows?.length) {
-          return
-        }
-
-        row.subRows = recurseFilterRows(row.subRows, depth + 1)
-      }
-    })
-
-    return rowsToFilter
-  }
-
-  return {
-    rows: recurseFilterRows(rowModel.rows),
-    flatRows: newFilteredFlatRows,
-    rowsById: newFilteredRowsById,
-  }
-}

package/src/utils/expandRowsFn.ts

@@ -1,30 +0,0 @@
-import { PartialGenerics, TableInstance, Row, RowModel } from '../types'
-
-export function expandRowsFn<TGenerics extends PartialGenerics>(
-  instance: TableInstance<TGenerics>,
-  sortedRowModel: RowModel<TGenerics>
-): RowModel<TGenerics> {
-  const expandedRows: Row<TGenerics>[] = []
-
-  const { expandSubRows } = instance.options
-
-  const handleRow = (row: Row<TGenerics>) => {
-    expandedRows.push(row)
-
-    if (
-      expandSubRows &&
-      row.subRows?.length &&
-      instance.getIsRowExpanded(row.id)
-    ) {
-      row.subRows.forEach(handleRow)
-    }
-  }
-
-  sortedRowModel.rows.forEach(handleRow)
-
-  return {
-    rows: expandedRows,
-    flatRows: sortedRowModel.flatRows,
-    rowsById: sortedRowModel.rowsById,
-  }
-}

package/src/utils/globalFilterRowsFn.ts

@@ -1,89 +0,0 @@
-import { PartialGenerics, TableInstance, Row, RowModel } from '../types'
-
-export function globalFilterRowsFn<TGenerics extends PartialGenerics>(
-  instance: TableInstance<TGenerics>,
-  rowModel: RowModel<TGenerics>
-): RowModel<TGenerics> {
-  const globalFilter = instance.getState().globalFilter
-  const newFilteredFlatRows: Row<TGenerics>[] = []
-  const newFilteredRowsById: Record<string, Row<TGenerics>> = {}
-
-  const filterFromChildrenUp = instance.options.filterFromChildrenUp
-
-  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)
-
-  if (filterFromChildrenUp) {
-    const recurseFilterRows = (rowsToFilter: Row<TGenerics>[], depth = 0) => {
-      // Filter from children up
-      rowsToFilter = rowsToFilter.filter(row => {
-        if (!row.subRows?.length) {
-          return true
-        }
-
-        row.subRows = recurseFilterRows(row.subRows, depth + 1)
-
-        return row.subRows.length
-      })
-
-      rowsToFilter = filterFn(rowsToFilter, filterableColumnIds, globalFilter)
-
-      // Apply the filter to any subRows
-      rowsToFilter.forEach(row => {
-        newFilteredFlatRows.push(row)
-        newFilteredRowsById[row.id] = row
-      })
-
-      return rowsToFilter
-    }
-
-    return {
-      rows: recurseFilterRows(rowModel.rows),
-      flatRows: newFilteredFlatRows,
-      rowsById: newFilteredRowsById,
-    }
-  }
-
-  // Filters top level and nested rows
-  const recurseFilterRows = (rowsToFilter: Row<TGenerics>[], depth = 0) => {
-    // Filter from parents downward
-    rowsToFilter = filterFn(rowsToFilter, filterableColumnIds, globalFilter)
-
-    // Apply the filter to any subRows
-    // We technically could do this recursively in the above loop,
-    // but that would severely hinder the API for the user, since they
-    // would be required to do that recursion in some scenarios
-    rowsToFilter.forEach(row => {
-      newFilteredFlatRows.push(row)
-      newFilteredRowsById[row.id] = row
-
-      if (!filterFromChildrenUp) {
-        if (!row.subRows?.length) {
-          return
-        }
-
-        row.subRows = recurseFilterRows(row.subRows, depth + 1)
-      }
-    })
-
-    return rowsToFilter
-  }
-
-  return {
-    rows: recurseFilterRows(rowModel.rows),
-    flatRows: newFilteredFlatRows,
-    rowsById: newFilteredRowsById,
-  }
-}

package/src/utils/groupRowsFn.ts

@@ -1,170 +0,0 @@
-import { PartialGenerics, TableInstance, Row, RowModel } from '../types'
-import { flattenBy } from '../utils'
-
-export function groupRowsFn<TGenerics extends PartialGenerics>(
-  instance: TableInstance<TGenerics>,
-  sortedRowModel: RowModel<TGenerics>
-): RowModel<TGenerics> {
-  const groupingState = instance.getState().grouping
-  // Filter the grouping list down to columns that exist
-  const existingGrouping = groupingState.filter(columnId =>
-    instance.getColumn(columnId)
-  )
-
-  // Find the columns that can or are aggregating
-  // Uses each column to aggregate rows into a single value
-  const aggregateRowsToValues = (
-    leafRows: Row<TGenerics>[],
-    groupedRows: Row<TGenerics>[],
-    depth: number
-  ) => {
-    const values: Record<string, unknown> = {}
-
-    instance.getAllLeafColumns().forEach(column => {
-      // Don't aggregate columns that are in the grouping
-      if (existingGrouping.includes(column.id)) {
-        values[column.id] = groupedRows[0]
-          ? groupedRows[0].values[column.id]
-          : null
-        return
-      }
-
-      // Aggregate the values
-      const aggregateFn = instance.getColumnAggregationFn(column.id)
-
-      if (aggregateFn) {
-        // Get the columnValues to aggregate
-        const groupedValues = groupedRows.map(row => row.values[column.id])
-
-        // Get the columnValues to aggregate
-        const leafValues = leafRows.map(row => {
-          let columnValue = row.values[column.id]
-
-          if (!depth && column.aggregateValue) {
-            columnValue = column.aggregateValue(columnValue)
-          }
-
-          return columnValue
-        })
-
-        values[column.id] = aggregateFn(leafValues, groupedValues)
-      } else if (column.aggregationType) {
-        console.info({ column })
-        throw new Error(
-          process.env.NODE_ENV !== 'production'
-            ? `React Table: Invalid column.aggregateType option for column listed above`
-            : ''
-        )
-      } else {
-        values[column.id] = null
-      }
-    })
-
-    return values
-  }
-
-  const groupedFlatRows: Row<TGenerics>[] = []
-  const groupedRowsById: Record<string, Row<TGenerics>> = {}
-  // const onlyGroupedFlatRows: Row[] = [];
-  // const onlyGroupedRowsById: Record<RowId, Row> = {};
-  // const nonGroupedFlatRows: Row[] = [];
-  // const nonGroupedRowsById: Record<RowId, Row> = {};
-
-  // Recursively group the data
-  const groupUpRecursively = (
-    rows: Row<TGenerics>[],
-    depth = 0,
-    parentId: string
-  ) => {
-    // This is the last level, just return the rows
-    if (depth === existingGrouping.length) {
-      return rows
-    }
-
-    const columnId = existingGrouping[depth]!
-
-    // Group the rows together for this level
-    const rowGroupsMap = groupBy(rows, columnId)
-
-    // Peform aggregations for each group
-    const aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map(
-      ([groupingValue, groupedRows], index) => {
-        let id = `${columnId}:${groupingValue}`
-        id = parentId ? `${parentId}>${id}` : id
-
-        // First, Recurse to group sub rows before aggregation
-        const subRows = groupUpRecursively(groupedRows, depth + 1, id)
-
-        // Flatten the leaf rows of the rows in this group
-        const leafRows = depth
-          ? flattenBy(groupedRows, row => row.leafRows)
-          : groupedRows
-
-        const values = aggregateRowsToValues(leafRows, groupedRows, depth)
-
-        const row = instance.createRow(id, undefined, index, depth, values)
-
-        Object.assign(row, {
-          groupingColumnId: columnId,
-          groupingValue,
-          subRows,
-          leafRows,
-        })
-
-        subRows.forEach(subRow => {
-          groupedFlatRows.push(subRow)
-          groupedRowsById[subRow.id] = subRow
-          // if (subRow.getIsGrouped?.()) {
-          //   onlyGroupedFlatRows.push(subRow);
-          //   onlyGroupedRowsById[subRow.id] = subRow;
-          // } else {
-          //   nonGroupedFlatRows.push(subRow);
-          //   nonGroupedRowsById[subRow.id] = subRow;
-          // }
-        })
-
-        return row
-      }
-    )
-
-    return aggregatedGroupedRows
-  }
-
-  const groupedRows = groupUpRecursively(sortedRowModel.rows, 0, '')
-
-  groupedRows.forEach(subRow => {
-    groupedFlatRows.push(subRow)
-    groupedRowsById[subRow.id] = subRow
-    // if (subRow.getIsGrouped?.()) {
-    //   onlyGroupedFlatRows.push(subRow);
-    //   onlyGroupedRowsById[subRow.id] = subRow;
-    // } else {
-    //   nonGroupedFlatRows.push(subRow);
-    //   nonGroupedRowsById[subRow.id] = subRow;
-    // }
-  })
-
-  return {
-    rows: groupedRows,
-    flatRows: groupedFlatRows,
-    rowsById: groupedRowsById,
-  }
-}
-
-function groupBy<TGenerics extends PartialGenerics>(
-  rows: Row<TGenerics>[],
-  columnId: string
-) {
-  const groupMap = new Map<any, Row<TGenerics>[]>()
-
-  return rows.reduce((map, row) => {
-    const resKey = `${row.values[columnId]}`
-    const previous = map.get(resKey)
-    if (!previous) {
-      map.set(resKey, [row])
-    } else {
-      map.set(resKey, [...previous, row])
-    }
-    return map
-  }, groupMap)
-}

package/src/utils/paginateRowsFn.ts

@@ -1,28 +0,0 @@
-import { PartialGenerics, TableInstance, RowModel } from '../types'
-import { expandRowsFn } from './expandRowsFn'
-
-export function paginateRowsFn<TGenerics extends PartialGenerics>(
-  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,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,
-  }
-}