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

package/src/sortTypes.ts

@@ -1,4 +1,4 @@
-import { Row } from './types'
+import { PartialGenerics, Row } from './types'
 
 export const reSplitAlphaNumeric = /([0-9]+)/gm
 
@@ -13,9 +13,9 @@ export const sortTypes = {
 
 export type BuiltInSortType = keyof typeof sortTypes
 
-function alphanumeric<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
+function alphanumeric<TGenerics extends PartialGenerics>(
+  rowA: Row<TGenerics>,
+  rowB: Row<TGenerics>,
   columnId: string
 ) {
   return compareAlphanumeric(
@@ -24,15 +24,9 @@ function alphanumeric<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
   )
 }
 
-function alphanumericCaseSensitive<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
+function alphanumericCaseSensitive<TGenerics extends PartialGenerics>(
+  rowA: Row<TGenerics>,
+  rowB: Row<TGenerics>,
   columnId: string
 ) {
   return compareAlphanumeric(
@@ -90,9 +84,9 @@ function compareAlphanumeric(aStr: string, bStr: string) {
 
 // The text filter is more basic (less numeric support)
 // but is much faster
-function text<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
+function text<TGenerics extends PartialGenerics>(
+  rowA: Row<TGenerics>,
+  rowB: Row<TGenerics>,
   columnId: string
 ) {
   return compareBasic(
@@ -103,15 +97,9 @@ function text<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
 
 // The text filter is more basic (less numeric support)
 // but is much faster
-function textCaseSensitive<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
+function textCaseSensitive<TGenerics extends PartialGenerics>(
+  rowA: Row<TGenerics>,
+  rowB: Row<TGenerics>,
   columnId: string
 ) {
   return compareBasic(
@@ -120,9 +108,9 @@ function textCaseSensitive<
   )
 }
 
-function datetime<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
+function datetime<TGenerics extends PartialGenerics>(
+  rowA: Row<TGenerics>,
+  rowB: Row<TGenerics>,
   columnId: string
 ) {
   return compareBasic(
@@ -131,9 +119,9 @@ function datetime<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
   )
 }
 
-function basic<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
-  rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
+function basic<TGenerics extends PartialGenerics>(
+  rowA: Row<TGenerics>,
+  rowB: Row<TGenerics>,
   columnId: string
 ) {
   return compareBasic(rowA.values[columnId], rowB.values[columnId])

package/src/types.ts

@@ -53,11 +53,13 @@ import {
   ExpandedInstance,
   ExpandedOptions,
   ExpandedTableState,
+  ExpandedRow,
 } from './features/Expanding'
 import { Overwrite } from './utils'
 import {
   ColumnSizingColumn,
   ColumnSizingColumnDef,
+  ColumnSizingHeader,
   ColumnSizingInstance,
   ColumnSizingOptions,
   ColumnSizingTableState,
@@ -78,36 +80,29 @@ import {
 //   const process.env.NODE_ENV !== 'production': boolean
 // }
 
-export type ReactTable<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = TableCore<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  VisibilityInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  ColumnOrderInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  ColumnPinningInstance<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  > &
-  HeadersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  FiltersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  SortingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  GroupingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  ColumnSizingInstance<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  > &
-  ExpandedInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  PaginationInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-  RowSelectionInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+export type DefaultGenerics = {
+  Row: unknown
+  Value: unknown
+  FilterFns: object
+  SortingFns: object
+  AggregationFns: object
+}
+
+export type PartialGenerics = Partial<DefaultGenerics>
+
+export type TableInstance<TGenerics extends PartialGenerics> =
+  TableCore<TGenerics> &
+    VisibilityInstance<TGenerics> &
+    ColumnOrderInstance<TGenerics> &
+    ColumnPinningInstance<TGenerics> &
+    HeadersInstance<TGenerics> &
+    FiltersInstance<TGenerics> &
+    SortingInstance<TGenerics> &
+    GroupingInstance<TGenerics> &
+    ColumnSizingInstance<TGenerics> &
+    ExpandedInstance<TGenerics> &
+    PaginationInstance<TGenerics> &
+    RowSelectionInstance<TGenerics>
 
 export type Renderable<TProps> =
   | React.ReactNode
@@ -116,18 +111,18 @@ export type Renderable<TProps> =
 
 //
 
-export type Options<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  CoreOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
+export type Options<TGenerics extends PartialGenerics> =
+  CoreOptions<TGenerics> &
     VisibilityOptions &
     ColumnOrderOptions &
     ColumnPinningOptions &
-    FiltersOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    SortingOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    GroupingOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    ExpandedOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
+    FiltersOptions<TGenerics> &
+    SortingOptions<TGenerics> &
+    GroupingOptions<TGenerics> &
+    ExpandedOptions<TGenerics> &
     ColumnSizingOptions &
-    PaginationOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    RowSelectionOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+    PaginationOptions<TGenerics> &
+    RowSelectionOptions<TGenerics>
 
 export type Updater<T> = T | ((old: T) => T)
 export type OnChangeFn<T> = (updaterOrValue: Updater<T>, value: T) => void
@@ -143,101 +138,88 @@ export type TableState = VisibilityTableState &
   PaginationTableState &
   RowSelectionTableState
 
-export type Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  CoreRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    VisibilityRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    HeadersRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    GroupingRow &
-    RowSelectionRow
+export type Row<TGenerics extends PartialGenerics> = CoreRow<TGenerics> &
+  VisibilityRow<TGenerics> &
+  HeadersRow<TGenerics> &
+  GroupingRow &
+  RowSelectionRow &
+  ExpandedRow
 
 export type RowValues = {
   [key: string]: any
 }
 
-export type RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  {
-    rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-    flatRows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-    rowsById: Record<
-      string,
-      Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-    >
-  }
+export type RowModel<TGenerics extends PartialGenerics> = {
+  rows: Row<TGenerics>[]
+  flatRows: Row<TGenerics>[]
+  rowsById: Record<string, Row<TGenerics>>
+}
 
 export type AccessorFn<TData> = (originalRow: TData, index: number) => any
 
-export type ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  CoreColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
+export const Please_use_the_create_table_column_utilities_to_define_columns: unique symbol =
+  Symbol()
+
+export type _NonGenerated<T> = Overwrite<
+  T,
+  {
+    [Please_use_the_create_table_column_utilities_to_define_columns]?: never
+  }
+>
+
+export type ColumnDef<TGenerics extends PartialGenerics> =
+  CoreColumnDef<TGenerics> &
     VisibilityColumnDef &
     ColumnPinningColumnDef &
-    FiltersColumnDef<TFilterFns> &
-    SortingColumnDef<TSortingFns> &
-    GroupingColumnDef<TAggregationFns> &
+    FiltersColumnDef<TGenerics> &
+    SortingColumnDef<TGenerics> &
+    GroupingColumnDef<TGenerics> &
     ColumnSizingColumnDef
 
-export type Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    CoreColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    ColumnVisibilityColumn &
-    ColumnPinningColumn &
-    FiltersColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    SortingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    GroupingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> &
-    ColumnSizingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-
-export type Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+export type Column<TGenerics extends PartialGenerics> = ColumnDef<TGenerics> &
+  CoreColumn<TGenerics> &
+  ColumnVisibilityColumn &
+  ColumnPinningColumn &
+  FiltersColumn<TGenerics> &
+  SortingColumn<TGenerics> &
+  GroupingColumn<TGenerics> &
+  ColumnSizingColumn<TGenerics>
+
+export type Cell<TGenerics extends PartialGenerics> = {
   id: string
   rowId: string
   columnId: string
-  value: TValue
-  row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+  value: TGenerics['Value']
+  row: Row<TGenerics>
+  column: Column<TGenerics>
   getCellProps: PropGetter<CellProps>
   renderCell: () => React.ReactNode
 }
 
-export type Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> =
-  CoreHeader<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+export type Header<TGenerics extends PartialGenerics> = CoreHeader<TGenerics> &
+  ColumnSizingHeader<TGenerics>
 
-export type CoreHeader<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
+export type CoreHeader<TGenerics extends PartialGenerics> = {
   id: string
   depth: number
-  column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
+  column: Column<TGenerics>
   getWidth: () => number
-  subHeaders: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
+  subHeaders: Header<TGenerics>[]
   colSpan?: number
   rowSpan?: number
   getHeaderProps: PropGetter<HeaderProps>
   getFooterProps: PropGetter<HeaderProps>
-  getLeafHeaders: () => Header<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[]
+  getLeafHeaders: () => Header<TGenerics>[]
   isPlaceholder?: boolean
   placeholderId?: string
   renderHeader: (options?: { renderPlaceholder?: boolean }) => React.ReactNode
   renderFooter: (options?: { renderPlaceholder?: boolean }) => React.ReactNode
 }
 
-export type HeaderGroup<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
-> = {
+export type HeaderGroup<TGenerics extends PartialGenerics> = {
   id: string
   depth: number
-  headers: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
+  headers: Header<TGenerics>[]
   getHeaderGroupProps: PropGetter<HeaderGroupProps>
   getFooterGroupProps: PropGetter<FooterGroupProps>
 }
@@ -307,8 +289,6 @@ export type CellProps = {
   role: string
 }
 
-export type Listener<TArgs extends [...any]> = (...args: [...TArgs]) => void
-
 //
 
 export type PropGetter<TBase> = <TGetter extends Getter<TBase>>(

package/src/utils/columnFilterRowsFn.ts

@@ -1,41 +1,17 @@
-import { ReactTable, Row, RowModel } from '../types'
-
-export function columnFilterRowsFn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
+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<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[] = []
-  const newFilteredRowsById: Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  > = {}
+  const newFilteredFlatRows: Row<TGenerics>[] = []
+  const newFilteredRowsById: Record<string, Row<TGenerics>> = {}
 
   const filterFromChildrenUp = instance.options.filterFromChildrenUp
 
-  const filterRows = (
-    rowsToFilter: Row<
-      TData,
-      TValue,
-      TFilterFns,
-      TSortingFns,
-      TAggregationFns
-    >[],
-    depth: number
-  ) => {
+  const filterRows = (rowsToFilter: Row<TGenerics>[], depth: number) => {
     columnFilters.forEach(({ id: columnId, value: filterValue }) => {
       // Find the columnFilters column
       const column = instance.getColumn(columnId)
@@ -74,16 +50,7 @@ export function columnFilterRowsFn<
   }
 
   if (filterFromChildrenUp) {
-    const recurseFilterRows = (
-      rowsToFilter: Row<
-        TData,
-        TValue,
-        TFilterFns,
-        TSortingFns,
-        TAggregationFns
-      >[],
-      depth = 0
-    ) => {
+    const recurseFilterRows = (rowsToFilter: Row<TGenerics>[], depth = 0) => {
       // Filter from children up
       rowsToFilter = rowsToFilter.filter(row => {
         if (!row.subRows?.length) {
@@ -114,16 +81,7 @@ export function columnFilterRowsFn<
   }
 
   // Filters top level and nested rows
-  const recurseFilterRows = (
-    rowsToFilter: Row<
-      TData,
-      TValue,
-      TFilterFns,
-      TSortingFns,
-      TAggregationFns
-    >[],
-    depth = 0
-  ) => {
+  const recurseFilterRows = (rowsToFilter: Row<TGenerics>[], depth = 0) => {
     // Filter from parents downward
     rowsToFilter = filterRows(rowsToFilter, depth)
 

package/src/utils/expandRowsFn.ts

@@ -1,34 +1,14 @@
-import { ReactTable, Row, RowModel } from '../types'
+import { PartialGenerics, TableInstance, Row, RowModel } from '../types'
 
-export function expandRowsFn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  sortedRowModel: RowModel<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >
-): RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
-  const expandedRows: Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[] = []
+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<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  ) => {
+  const handleRow = (row: Row<TGenerics>) => {
     expandedRows.push(row)
 
     if (

package/src/utils/globalFilterRowsFn.ts

@@ -1,27 +1,12 @@
-import { ReactTable, Row, RowModel } from '../types'
-
-export function globalFilterRowsFn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
+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<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[] = []
-  const newFilteredRowsById: Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  > = {}
+  const newFilteredFlatRows: Row<TGenerics>[] = []
+  const newFilteredRowsById: Record<string, Row<TGenerics>> = {}
 
   const filterFromChildrenUp = instance.options.filterFromChildrenUp
 
@@ -41,16 +26,7 @@ export function globalFilterRowsFn<
   const filterableColumnIds = filterableColumns.map(d => d.id)
 
   if (filterFromChildrenUp) {
-    const recurseFilterRows = (
-      rowsToFilter: Row<
-        TData,
-        TValue,
-        TFilterFns,
-        TSortingFns,
-        TAggregationFns
-      >[],
-      depth = 0
-    ) => {
+    const recurseFilterRows = (rowsToFilter: Row<TGenerics>[], depth = 0) => {
       // Filter from children up
       rowsToFilter = rowsToFilter.filter(row => {
         if (!row.subRows?.length) {
@@ -81,16 +57,7 @@ export function globalFilterRowsFn<
   }
 
   // Filters top level and nested rows
-  const recurseFilterRows = (
-    rowsToFilter: Row<
-      TData,
-      TValue,
-      TFilterFns,
-      TSortingFns,
-      TAggregationFns
-    >[],
-    depth = 0
-  ) => {
+  const recurseFilterRows = (rowsToFilter: Row<TGenerics>[], depth = 0) => {
     // Filter from parents downward
     rowsToFilter = filterFn(rowsToFilter, filterableColumnIds, globalFilter)
 

package/src/utils/groupRowsFn.ts

@@ -1,22 +1,10 @@
-import { ReactTable, Row, RowModel } from '../types'
+import { PartialGenerics, TableInstance, Row, RowModel } from '../types'
 import { flattenBy } from '../utils'
 
-export function groupRowsFn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  sortedRowModel: RowModel<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >
-): RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
+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 =>
@@ -26,8 +14,8 @@ export function groupRowsFn<
   // Find the columns that can or are aggregating
   // Uses each column to aggregate rows into a single value
   const aggregateRowsToValues = (
-    leafRows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
-    groupedRows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
+    leafRows: Row<TGenerics>[],
+    groupedRows: Row<TGenerics>[],
     depth: number
   ) => {
     const values: Record<string, unknown> = {}
@@ -75,17 +63,8 @@ export function groupRowsFn<
     return values
   }
 
-  const groupedFlatRows: Row<
-    TData,
-    TValue,
-    TFilterFns,
-    TSortingFns,
-    TAggregationFns
-  >[] = []
-  const groupedRowsById: Record<
-    string,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-  > = {}
+  const groupedFlatRows: Row<TGenerics>[] = []
+  const groupedRowsById: Record<string, Row<TGenerics>> = {}
   // const onlyGroupedFlatRows: Row[] = [];
   // const onlyGroupedRowsById: Record<RowId, Row> = {};
   // const nonGroupedFlatRows: Row[] = [];
@@ -93,7 +72,7 @@ export function groupRowsFn<
 
   // Recursively group the data
   const groupUpRecursively = (
-    rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
+    rows: Row<TGenerics>[],
     depth = 0,
     parentId: string
   ) => {
@@ -172,14 +151,11 @@ export function groupRowsFn<
   }
 }
 
-function groupBy<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(
-  rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[],
+function groupBy<TGenerics extends PartialGenerics>(
+  rows: Row<TGenerics>[],
   columnId: string
 ) {
-  const groupMap = new Map<
-    any,
-    Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]
-  >()
+  const groupMap = new Map<any, Row<TGenerics>[]>()
 
   return rows.reduce((map, row) => {
     const resKey = `${row.values[columnId]}`

package/src/utils/paginateRowsFn.ts

@@ -1,16 +1,10 @@
-import { ReactTable, RowModel } from '../types'
+import { PartialGenerics, TableInstance, RowModel } from '../types'
 import { expandRowsFn } from './expandRowsFn'
 
-export function paginateRowsFn<
-  TData,
-  TValue,
-  TFilterFns,
-  TSortingFns,
-  TAggregationFns
->(
-  instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>,
-  rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>
-): RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> {
+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