@tanstack/react-table 8.0.0-alpha.6 → 8.0.0-alpha.9

package/src/features/Ordering.ts

@@ -1,6 +1,12 @@
 import { functionalUpdate, makeStateUpdater, memo } from '../utils'
 
-import { ReactTable, OnChangeFn, Updater, Column } from '../types'
+import {
+  TableInstance,
+  OnChangeFn,
+  Updater,
+  Column,
+  PartialGenerics,
+} from '../types'
 
 import * as Grouping from './Grouping'
 
@@ -18,18 +24,10 @@ export type ColumnOrderDefaultOptions = {
   onColumnOrderChange: OnChangeFn<ColumnOrderState>
 }
 
-export type ColumnOrderInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
+export type ColumnOrderInstance<TGenerics extends PartialGenerics> = {
   setColumnOrder: (updater: Updater<ColumnOrderState>) => void
   resetColumnOrder: () => void
-  getOrderColumnsFn: () => (
-    columns: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-  ) => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
+  getOrderColumnsFn: () => (columns: Column<TGenerics>[]) => Column<TGenerics>[]
 }
 
 //
@@ -40,35 +38,17 @@ export function getInitialState(): ColumnOrderTableState {
   }
 }
 
-export function getDefaultOptions<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+export function getDefaultOptions<TGenerics extends PartialGenerics>(
+  instance: TableInstance<TGenerics>
 ): ColumnOrderDefaultOptions {
   return {
     onColumnOrderChange: makeStateUpdater('columnOrder', instance),
   }
 }
 
-export function getInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): ColumnOrderInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> {
+export function getInstance<TGenerics extends PartialGenerics>(
+  instance: TableInstance<TGenerics>
+): ColumnOrderInstance<TGenerics> {
   return {
     setColumnOrder: updater =>
       instance.options.onColumnOrderChange?.(
@@ -87,13 +67,7 @@ export function getInstance<
       (columnOrder, grouping, groupedColumnMode) => columns => {
         // Sort grouped columns to the start of the column list
         // before the headers are built
-        let orderedColumns: Column<
-          TData,
-          TValue,
-          TFilterFns,
-          TSortingFns,
-          TAggregationFns
-        >[] = []
+        let orderedColumns: Column<TGenerics>[] = []
 
         // If there is no order, return the normal columns
         if (!columnOrder?.length) {
@@ -127,7 +101,10 @@ export function getInstance<
           groupedColumnMode
         )
       },
-      { key: 'getOrderColumnsFn', debug: instance.options.debug }
+      {
+        key: 'getOrderColumnsFn',
+        // debug: () => instance.options.debugAll ?? instance.options.debugTable,
+      }
     ),
   }
 }

package/src/features/Pagination.ts

@@ -1,7 +1,8 @@
 import {
   Column,
   OnChangeFn,
-  ReactTable,
+  PartialGenerics,
+  TableInstance,
   Row,
   RowModel,
   TableState,
@@ -9,37 +10,23 @@ import {
 } from '../types'
 import { functionalUpdate, makeStateUpdater, memo } from '../utils'
 
-export type PageCount = undefined | null | number
-
 export type PaginationState = {
   pageIndex: number
   pageSize: number
-  pageCount?: PageCount
+  pageCount: number
 }
 
 export type PaginationTableState = {
   pagination: PaginationState
 }
 
-export type PaginationOptions<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
+export type PaginationOptions<TGenerics extends PartialGenerics> = {
   onPaginationChange?: OnChangeFn<PaginationState>
   autoResetPageIndex?: boolean
   paginateRowsFn?: (
-    instance: ReactTable<
-      TData,
-      TValue,
-      TFilterFns,
-      TSortingFns,
-      TAggregationFns
-    >,
-    rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  ) => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+    instance: TableInstance<TGenerics>,
+    rowModel: RowModel<TGenerics>
+  ) => RowModel<TGenerics>
 }
 
 export type PaginationDefaultOptions = {
@@ -47,13 +34,7 @@ export type PaginationDefaultOptions = {
   autoResetPageIndex: boolean
 }
 
-export type PaginationInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
+export type PaginationInstance<TGenerics extends PartialGenerics> = {
   _notifyPageIndexReset: () => void
   setPagination: (updater: Updater<PaginationState>) => void
   resetPagination: () => void
@@ -61,55 +42,15 @@ export type PaginationInstance<
   resetPageIndex: () => void
   setPageSize: (updater: Updater<number>) => void
   resetPageSize: () => void
-  setPageCount: (updater: Updater<PageCount>) => void
+  setPageCount: (updater: Updater<number>) => void
   getPageOptions: () => number[]
   getCanPreviousPage: () => boolean
   getCanNextPage: () => boolean
   previousPage: () => void
   nextPage: () => void
-  getPaginationRowModel: () => RowModel<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >
-  getPrePaginationRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getPrePaginationFlatRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getPrePaginationRowsById: () => Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  >
-  getPaginationRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getPaginationFlatRows: () => Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
-  getPaginationRowsById: () => Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  >
+  getPrePaginationRowModel: () => RowModel<TGenerics>
+  getPaginationRowModel: () => RowModel<TGenerics>
+  getPageCount: () => number
 }
 
 //
@@ -117,20 +58,15 @@ export type PaginationInstance<
 export function getInitialState(): PaginationTableState {
   return {
     pagination: {
+      pageCount: -1,
       pageIndex: 0,
       pageSize: 10,
     },
   }
 }
 
-export function getDefaultOptions<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+export function getDefaultOptions<TGenerics extends PartialGenerics>(
+  instance: TableInstance<TGenerics>
 ): PaginationDefaultOptions {
   return {
     onPaginationChange: makeStateUpdater('pagination', instance),
@@ -138,15 +74,9 @@ export function getDefaultOptions<
   }
 }
 
-export function getInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): PaginationInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
+export function getInstance<TGenerics extends PartialGenerics>(
+  instance: TableInstance<TGenerics>
+): PaginationInstance<TGenerics> {
   let registered = false
   return {
     _notifyPageIndexReset: () => {
@@ -163,22 +93,13 @@ export function getInstance<
         instance.options.autoResetAll === true ||
         instance.options.autoResetPageIndex
       ) {
-        instance.resetPageSize()
+        instance.resetPageIndex()
       }
     },
     setPagination: updater => {
       const safeUpdater: Updater<PaginationState> = old => {
         let newState = functionalUpdate(updater, old)
 
-        if (instance.options.paginateRowsFn) {
-          newState.pageCount = instance.getPrePaginationRows()?.length
-            ? Math.ceil(
-                instance.getPrePaginationRows().length /
-                  instance.getState().pagination.pageSize
-              )
-            : 0
-        }
-
         return newState
       }
 
@@ -260,7 +181,7 @@ export function getInstance<
       },
       {
         key: 'getPageOptions',
-        debug: instance.options.debug,
+        debug: () => instance.options.debugAll ?? instance.options.debugTable,
       }
     ),
 
@@ -279,7 +200,8 @@ export function getInstance<
 
       return (
         pageIndex <
-        Math.ceil(instance.getPrePaginationRows().length / pageSize) - 1
+        Math.ceil(instance.getPrePaginationRowModel().rows.length / pageSize) -
+          1
       )
     },
 
@@ -293,6 +215,7 @@ export function getInstance<
       })
     },
 
+    getPrePaginationRowModel: () => instance.getExpandedRowModel(),
     getPaginationRowModel: memo(
       () => [
         instance.getState().pagination,
@@ -304,22 +227,24 @@ export function getInstance<
           return rowModel
         }
 
-        if (process.env.NODE_ENV !== 'production' && instance.options.debug)
-          console.info('Paginating...')
-
         return paginateRowsFn(instance, rowModel)
       },
       {
         key: 'getPaginationRowModel',
-        debug: instance.options.debug,
+        debug: () => instance.options.debugAll ?? instance.options.debugTable,
       }
     ),
 
-    getPrePaginationRows: () => instance.getExpandedRowModel().rows,
-    getPrePaginationFlatRows: () => instance.getExpandedRowModel().flatRows,
-    getPrePaginationRowsById: () => instance.getExpandedRowModel().rowsById,
-    getPaginationRows: () => instance.getPaginationRowModel().rows,
-    getPaginationFlatRows: () => instance.getPaginationRowModel().flatRows,
-    getPaginationRowsById: () => instance.getPaginationRowModel().rowsById,
+    getPageCount: () => {
+      const { pageCount } = instance.getState().pagination
+      if (pageCount > 0) {
+        return pageCount
+      }
+
+      return Math.ceil(
+        instance.getPrePaginationRowModel().rows.length /
+          instance.getState().pagination.pageSize
+      )
+    },
   }
 }

package/src/features/Pinning.ts

@@ -1,4 +1,10 @@
-import { OnChangeFn, Updater, ReactTable, Column } from '../types'
+import {
+  OnChangeFn,
+  Updater,
+  TableInstance,
+  Column,
+  PartialGenerics,
+} from '../types'
 import { functionalUpdate, makeStateUpdater } from '../utils'
 
 type ColumnPinningPosition = false | 'left' | 'right'
@@ -33,13 +39,7 @@ export type ColumnPinningColumn = {
   pin: (position: ColumnPinningPosition) => void
 }
 
-export type ColumnPinningInstance<
-  _TData,
-  _TValue,
-  _TFilterFns,
-  _TSortingFns,
-  _TAggregationFns
-> = {
+export type ColumnPinningInstance<TGenerics extends PartialGenerics> = {
   setColumnPinning: (updater: Updater<ColumnPinningState>) => void
   resetColumnPinning: () => void
   pinColumn: (columnId: string, position: ColumnPinningPosition) => void
@@ -59,29 +59,17 @@ export function getInitialState(): ColumnPinningTableState {
   }
 }
 
-export function getDefaultOptions<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+export function getDefaultOptions<TGenerics extends PartialGenerics>(
+  instance: TableInstance<TGenerics>
 ): ColumnPinningDefaultOptions {
   return {
     onColumnPinningChange: makeStateUpdater('columnPinning', instance),
   }
 }
 
-export function createColumn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+export function createColumn<TGenerics extends PartialGenerics>(
+  column: Column<TGenerics>,
+  instance: TableInstance<TGenerics>
 ): ColumnPinningColumn {
   return {
     getCanPin: () => instance.getColumnCanPin(column.id),
@@ -91,21 +79,9 @@ export function createColumn<
   }
 }
 
-export function getInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): ColumnPinningInstance<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> {
+export function getInstance<TGenerics extends PartialGenerics>(
+  instance: TableInstance<TGenerics>
+): ColumnPinningInstance<TGenerics> {
   return {
     setColumnPinning: updater =>
       instance.options.onColumnPinningChange?.(