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

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/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()
-          })
-        },
-      }
-    )
-}