@tanstack/table-core 9.0.0-alpha.10 → 9.0.0-alpha.12

package/src/utils/getFacetedUniqueValues.ts

@@ -1,42 +0,0 @@
-import { Table, RowData } from '../types'
-import { getMemoOptions, memo } from '../utils'
-
-export function getFacetedUniqueValues<TData extends RowData>(): (
-  table: Table<TData>,
-  columnId: string
-) => () => Map<any, number> {
-  return (table, columnId) =>
-    memo(
-      () => [table.getColumn(columnId)?.getFacetedRowModel()],
-      facetedRowModel => {
-        if (!facetedRowModel) return new Map()
-
-        let facetedUniqueValues = new Map<any, number>()
-
-        for (let i = 0; i < facetedRowModel.flatRows.length; i++) {
-          const values =
-            facetedRowModel.flatRows[i]!.getUniqueValues<number>(columnId)
-
-          for (let j = 0; j < values.length; j++) {
-            const value = values[j]!
-
-            if (facetedUniqueValues.has(value)) {
-              facetedUniqueValues.set(
-                value,
-                (facetedUniqueValues.get(value) ?? 0) + 1
-              )
-            } else {
-              facetedUniqueValues.set(value, 1)
-            }
-          }
-        }
-
-        return facetedUniqueValues
-      },
-      getMemoOptions(
-        table.options,
-        'debugTable',
-        `getFacetedUniqueValues_${columnId}`
-      )
-    )
-}

package/src/utils/getFilteredRowModel.ts

@@ -1,151 +0,0 @@
-import { ResolvedColumnFilter } from '../features/ColumnFiltering'
-import { Table, RowModel, Row, RowData } from '../types'
-import { getMemoOptions, memo } from '../utils'
-import { filterRows } from './filterRowsUtils'
-
-export function getFilteredRowModel<TData extends RowData>(): (
-  table: Table<TData>
-) => () => RowModel<TData> {
-  return table =>
-    memo(
-      () => [
-        table.getPreFilteredRowModel(),
-        table.getState().columnFilters,
-        table.getState().globalFilter,
-      ],
-      (rowModel, columnFilters, globalFilter) => {
-        if (
-          !rowModel.rows.length ||
-          (!columnFilters?.length && !globalFilter)
-        ) {
-          for (let i = 0; i < rowModel.flatRows.length; i++) {
-            rowModel.flatRows[i]!.columnFilters = {}
-            rowModel.flatRows[i]!.columnFiltersMeta = {}
-          }
-          return rowModel
-        }
-
-        const resolvedColumnFilters: ResolvedColumnFilter<TData>[] = []
-        const resolvedGlobalFilters: ResolvedColumnFilter<TData>[] = []
-
-        ;(columnFilters ?? []).forEach(d => {
-          const column = table.getColumn(d.id)
-
-          if (!column) {
-            return
-          }
-
-          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 = table.getGlobalFilterFn()
-
-        const globallyFilterableColumns = table
-          .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,
-            })
-          })
-        }
-
-        let currentColumnFilter
-        let currentGlobalFilter
-
-        // Flag the prefiltered row model with each filter state
-        for (let j = 0; j < rowModel.flatRows.length; j++) {
-          const row = rowModel.flatRows[j]!
-
-          row.columnFilters = {}
-
-          if (resolvedColumnFilters.length) {
-            for (let i = 0; i < resolvedColumnFilters.length; i++) {
-              currentColumnFilter = resolvedColumnFilters[i]!
-              const id = currentColumnFilter.id
-
-              // Tag the row with the column filter state
-              row.columnFilters[id] = currentColumnFilter.filterFn(
-                row,
-                id,
-                currentColumnFilter.resolvedValue,
-                filterMeta => {
-                  row.columnFiltersMeta[id] = filterMeta
-                }
-              )
-            }
-          }
-
-          if (resolvedGlobalFilters.length) {
-            for (let i = 0; i < resolvedGlobalFilters.length; i++) {
-              currentGlobalFilter = resolvedGlobalFilters[i]!
-              const id = currentGlobalFilter.id
-              // Tag the row with the first truthy global filter state
-              if (
-                currentGlobalFilter.filterFn(
-                  row,
-                  id,
-                  currentGlobalFilter.resolvedValue,
-                  filterMeta => {
-                    row.columnFiltersMeta[id] = filterMeta
-                  }
-                )
-              ) {
-                row.columnFilters.__global__ = true
-                break
-              }
-            }
-
-            if (row.columnFilters.__global__ !== true) {
-              row.columnFilters.__global__ = false
-            }
-          }
-        }
-
-        const filterRowsImpl = (row: Row<TData>) => {
-          // Horizontally filter rows through each column
-          for (let i = 0; i < filterableIds.length; i++) {
-            if (row.columnFilters[filterableIds[i]!] === false) {
-              return false
-            }
-          }
-          return true
-        }
-
-        // Filter final rows using all of the active filters
-        return filterRows(rowModel.rows, filterRowsImpl, table)
-      },
-      getMemoOptions(table.options, 'debugTable', 'getFilteredRowModel', () =>
-        table._autoResetPageIndex()
-      )
-    )
-}

package/src/utils/getGroupedRowModel.ts

@@ -1,181 +0,0 @@
-import { _createRow } from '../core/row'
-import { Table, Row, RowModel, RowData } from '../types'
-import { flattenBy, getMemoOptions, memo } from '../utils'
-
-export function getGroupedRowModel<TData extends RowData>(): (
-  table: Table<TData>
-) => () => RowModel<TData> {
-  return table =>
-    memo(
-      () => [table.getState().grouping, table.getPreGroupedRowModel()],
-      (grouping, rowModel) => {
-        if (!rowModel.rows.length || !grouping.length) {
-          return rowModel
-        }
-
-        // Filter the grouping list down to columns that exist
-        const existingGrouping = grouping.filter(columnId =>
-          table.getColumn(columnId)
-        )
-
-        const groupedFlatRows: Row<TData>[] = []
-        const groupedRowsById: Record<string, Row<TData>> = {}
-        // const onlyGroupedFlatRows: Row[] = [];
-        // const onlyGroupedRowsById: Record<RowId, Row> = {};
-        // const nonGroupedFlatRows: Row[] = [];
-        // const nonGroupedRowsById: Record<RowId, Row> = {};
-
-        // Recursively group the data
-        const groupUpRecursively = (
-          rows: Row<TData>[],
-          depth = 0,
-          parentId?: string
-        ) => {
-          // Grouping depth has been been met
-          // Stop grouping and simply rewrite thd depth and row relationships
-          if (depth >= existingGrouping.length) {
-            return rows.map(row => {
-              row.depth = depth
-
-              groupedFlatRows.push(row)
-              groupedRowsById[row.id] = row
-
-              if (row.subRows) {
-                row.subRows = groupUpRecursively(row.subRows, depth + 1, row.id)
-              }
-
-              return row
-            })
-          }
-
-          const columnId: string = 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.subRows)
-                : groupedRows
-
-              const row = _createRow(
-                table,
-                id,
-                leafRows[0]!.original,
-                index,
-                depth,
-                undefined,
-                parentId
-              )
-
-              Object.assign(row, {
-                groupingColumnId: columnId,
-                groupingValue,
-                subRows,
-                leafRows,
-                getValue: (columnId: string) => {
-                  // Don't aggregate columns that are in the grouping
-                  if (existingGrouping.includes(columnId)) {
-                    if (row._valuesCache.hasOwnProperty(columnId)) {
-                      return row._valuesCache[columnId]
-                    }
-
-                    if (groupedRows[0]) {
-                      row._valuesCache[columnId] =
-                        groupedRows[0].getValue(columnId) ?? undefined
-                    }
-
-                    return row._valuesCache[columnId]
-                  }
-
-                  if (row._groupingValuesCache.hasOwnProperty(columnId)) {
-                    return row._groupingValuesCache[columnId]
-                  }
-
-                  // Aggregate the values
-                  const column = table.getColumn(columnId)
-                  const aggregateFn = column?.getAggregationFn()
-
-                  if (aggregateFn) {
-                    row._groupingValuesCache[columnId] = aggregateFn(
-                      columnId,
-                      leafRows,
-                      groupedRows
-                    )
-
-                    return row._groupingValuesCache[columnId]
-                  }
-                },
-              })
-
-              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(rowModel.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,
-        }
-      },
-      getMemoOptions(table.options, 'debugTable', 'getGroupedRowModel', () => {
-        table._queue(() => {
-          table._autoResetExpanded()
-          table._autoResetPageIndex()
-        })
-      })
-    )
-}
-
-function groupBy<TData extends RowData>(rows: Row<TData>[], columnId: string) {
-  const groupMap = new Map<any, Row<TData>[]>()
-
-  return rows.reduce((map, row) => {
-    const resKey = `${row.getGroupingValue(columnId)}`
-    const previous = map.get(resKey)
-    if (!previous) {
-      map.set(resKey, [row])
-    } else {
-      previous.push(row)
-    }
-    return map
-  }, groupMap)
-}

package/src/utils/getPaginationRowModel.ts

@@ -1,60 +0,0 @@
-import { Table, RowModel, Row, RowData } from '../types'
-import { getMemoOptions, memo } from '../utils'
-import { expandRows } from './getExpandedRowModel'
-
-export function getPaginationRowModel<TData extends RowData>(opts?: {
-  initialSync: boolean
-}): (table: Table<TData>) => () => RowModel<TData> {
-  return table =>
-    memo(
-      () => [
-        table.getState().pagination,
-        table.getPrePaginationRowModel(),
-        table.options.paginateExpandedRows
-          ? undefined
-          : table.getState().expanded,
-      ],
-      (pagination, rowModel) => {
-        if (!rowModel.rows.length) {
-          return rowModel
-        }
-
-        const { pageSize, pageIndex } = pagination
-        let { rows, flatRows, rowsById } = rowModel
-        const pageStart = pageSize * pageIndex
-        const pageEnd = pageStart + pageSize
-
-        rows = rows.slice(pageStart, pageEnd)
-
-        let paginatedRowModel: RowModel<TData>
-
-        if (!table.options.paginateExpandedRows) {
-          paginatedRowModel = expandRows({
-            rows,
-            flatRows,
-            rowsById,
-          })
-        } else {
-          paginatedRowModel = {
-            rows,
-            flatRows,
-            rowsById,
-          }
-        }
-
-        paginatedRowModel.flatRows = []
-
-        const handleRow = (row: Row<TData>) => {
-          paginatedRowModel.flatRows.push(row)
-          if (row.subRows.length) {
-            row.subRows.forEach(handleRow)
-          }
-        }
-
-        paginatedRowModel.rows.forEach(handleRow)
-
-        return paginatedRowModel
-      },
-      getMemoOptions(table.options, 'debugTable', 'getPaginationRowModel')
-    )
-}

package/src/utils/getSortedRowModel.ts

@@ -1,121 +0,0 @@
-import { Table, Row, RowModel, RowData } from '../types'
-import { SortingFn } from '../features/RowSorting'
-import { getMemoOptions, memo } from '../utils'
-
-export function getSortedRowModel<TData extends RowData>(): (
-  table: Table<TData>
-) => () => RowModel<TData> {
-  return table =>
-    memo(
-      () => [table.getState().sorting, table.getPreSortedRowModel()],
-      (sorting, rowModel) => {
-        if (!rowModel.rows.length || !sorting?.length) {
-          return rowModel
-        }
-
-        const sortingState = table.getState().sorting
-
-        const sortedFlatRows: Row<TData>[] = []
-
-        // Filter out sortings that correspond to non existing columns
-        const availableSorting = sortingState.filter(sort =>
-          table.getColumn(sort.id)?.getCanSort()
-        )
-
-        const columnInfoById: Record<
-          string,
-          {
-            sortUndefined?: false | -1 | 1 | 'first' | 'last'
-            invertSorting?: boolean
-            sortingFn: SortingFn<TData>
-          }
-        > = {}
-
-        availableSorting.forEach(sortEntry => {
-          const column = table.getColumn(sortEntry.id)
-          if (!column) return
-
-          columnInfoById[sortEntry.id] = {
-            sortUndefined: column.columnDef.sortUndefined,
-            invertSorting: column.columnDef.invertSorting,
-            sortingFn: column.getSortingFn(),
-          }
-        })
-
-        const sortData = (rows: Row<TData>[]) => {
-          // This will also perform a stable sorting using the row index
-          // if needed.
-          const sortedData = rows.map(row => ({ ...row }))
-
-          sortedData.sort((rowA, rowB) => {
-            for (let i = 0; i < availableSorting.length; i += 1) {
-              const sortEntry = availableSorting[i]!
-              const columnInfo = columnInfoById[sortEntry.id]!
-              const sortUndefined = columnInfo.sortUndefined
-              const isDesc = sortEntry?.desc ?? false
-
-              let sortInt = 0
-
-              // All sorting ints should always return in ascending order
-              if (sortUndefined) {
-                const aValue = rowA.getValue(sortEntry.id)
-                const bValue = rowB.getValue(sortEntry.id)
-
-                const aUndefined = aValue === undefined
-                const bUndefined = bValue === undefined
-
-                if (aUndefined || bUndefined) {
-                  if (sortUndefined === 'first') return aUndefined ? -1 : 1
-                  if (sortUndefined === 'last') return aUndefined ? 1 : -1
-                  sortInt =
-                    aUndefined && bUndefined
-                      ? 0
-                      : aUndefined
-                        ? sortUndefined
-                        : -sortUndefined
-                }
-              }
-
-              if (sortInt === 0) {
-                sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id)
-              }
-
-              // If sorting is non-zero, take care of desc and inversion
-              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?.length) {
-              row.subRows = sortData(row.subRows)
-            }
-          })
-
-          return sortedData
-        }
-
-        return {
-          rows: sortData(rowModel.rows),
-          flatRows: sortedFlatRows,
-          rowsById: rowModel.rowsById,
-        }
-      },
-      getMemoOptions(table.options, 'debugTable', 'getSortedRowModel', () =>
-        table._autoResetPageIndex()
-      )
-    )
-}