@tanstack/table-core 8.0.0-alpha.30 → 8.0.0-alpha.36

package/build/types/aggregationTypes.d.ts

@@ -14,7 +14,7 @@ declare function sum(_getLeafValues: () => unknown[], getChildValues: () => unkn
 declare function min(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): number | undefined;
 declare function max(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): number | undefined;
 declare function extent(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): (number | undefined)[];
-declare function mean(getLeafValues: () => unknown[]): number | undefined;
+export declare function mean(getLeafValues: () => unknown[]): number | undefined;
 declare function median(getLeafValues: () => unknown[]): number | undefined;
 declare function unique<T>(getLeafValues: () => T[]): T[];
 declare function uniqueCount(getLeafValues: () => unknown[]): number;

package/build/types/core.d.ts

@@ -1,11 +1,15 @@
 import { RequiredKeys } from './utils';
 import { Updater, PropGetterValue, Options, TableState, ColumnDef, Row, Column, Cell, Header, AccessorFn, TableProps, TableBodyProps, PropGetter, Getter, RowProps, CellProps, TableInstance, RowValues, Renderable, UseRenderer, RowModel, TableFeature, AnyGenerics } from './types';
+export declare type CoreTableState = {
+    coreProgress: number;
+};
 export declare type CoreOptions<TGenerics extends AnyGenerics> = {
     data: TGenerics['Row'][];
     columns: ColumnDef<TGenerics>[];
     state: Partial<TableState>;
     onStateChange: (updater: Updater<TableState>) => void;
     render: TGenerics['Render'];
+    getCoreRowModel: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     debugAll?: boolean;
     debugTable?: boolean;
     debugHeaders?: boolean;
@@ -17,13 +21,15 @@ export declare type CoreOptions<TGenerics extends AnyGenerics> = {
     getRowId?: (originalRow: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
     autoResetAll?: boolean;
     mergeOptions?: (defaultOptions: TableFeature, options: Partial<Options<TGenerics>>) => Options<TGenerics>;
-    meta?: TGenerics['TableMeta'] extends {} ? TGenerics['TableMeta'] : any;
+    meta?: TGenerics['TableMeta'];
 };
 export declare type TableCore<TGenerics extends AnyGenerics> = {
     initialState: TableState;
     reset: () => void;
     options: RequiredKeys<Options<TGenerics>, 'state'>;
     setOptions: (newOptions: Updater<Options<TGenerics>>) => void;
+    queue: (cb: () => void) => void;
+    willUpdate: () => void;
     getRowId: (_: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
     getState: () => TableState;
     setState: (updater: Updater<TableState>) => void;
@@ -39,6 +45,7 @@ export declare type TableCore<TGenerics extends AnyGenerics> = {
     createCell: (row: Row<TGenerics>, column: Column<TGenerics>, value: any) => Cell<TGenerics>;
     createRow: (id: string, original: TGenerics['Row'] | undefined, rowIndex: number, depth: number, values: Record<string, any>) => Row<TGenerics>;
     getCoreRowModel: () => RowModel<TGenerics>;
+    _getCoreRowModel?: () => RowModel<TGenerics>;
     getRowModel: () => RowModel<TGenerics>;
     getRow: (id: string) => Row<TGenerics>;
     getCell: (rowId: string, columnId: string) => Cell<TGenerics>;
@@ -51,6 +58,7 @@ export declare type TableCore<TGenerics extends AnyGenerics> = {
     getCenterTableWidth: () => number;
     getRightTableWidth: () => number;
     render: <TProps>(template: Renderable<TGenerics, TProps>, props: TProps) => string | null | ReturnType<UseRenderer<TGenerics>>;
+    getOverallProgress: () => number;
 };
 export declare type CoreRow<TGenerics extends AnyGenerics> = {
     id: string;

package/build/types/features/Expanding.d.ts

@@ -16,7 +16,7 @@ export declare type ExpandedOptions<TGenerics extends AnyGenerics> = {
     onExpandedChange?: OnChangeFn<ExpandedState>;
     autoResetExpanded?: boolean;
     enableExpanded?: boolean;
-    expandRowsFn?: (instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
+    getExpandedRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     expandSubRows?: boolean;
     defaultCanExpand?: boolean;
     getIsRowExpanded?: (row: Row<TGenerics>) => boolean;
@@ -41,6 +41,7 @@ export declare type ExpandedInstance<TGenerics extends AnyGenerics> = {
     getIsAllRowsExpanded: () => boolean;
     getExpandedDepth: () => number;
     getExpandedRowModel: () => RowModel<TGenerics>;
+    _getExpandedRowModel?: () => RowModel<TGenerics>;
     getPreExpandedRowModel: () => RowModel<TGenerics>;
 };
 export declare const Expanding: {

package/build/types/features/Filters.d.ts

@@ -16,6 +16,8 @@ export declare type CustomFilterTypes<TGenerics extends AnyGenerics> = Record<st
 export declare type FiltersTableState = {
     columnFilters: ColumnFiltersState;
     globalFilter: any;
+    columnFiltersProgress: number;
+    globalFilterProgress: number;
 };
 export declare type FilterType<TGenerics extends AnyGenerics> = 'auto' | BuiltInFilterType | TGenerics['FilterFns'] | FilterFn<TGenerics>;
 export declare type FiltersColumnDef<TGenerics extends AnyGenerics> = {
@@ -50,13 +52,13 @@ export declare type FiltersOptions<TGenerics extends AnyGenerics> = {
     onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
     autoResetColumnFilters?: boolean;
     enableColumnFilters?: boolean;
-    columnFilterRowsFn?: (instance: TableInstance<TGenerics>, coreRowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
+    getColumnFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     globalFilterType?: FilterType<TGenerics>;
     onGlobalFilterChange?: OnChangeFn<any>;
     enableGlobalFilters?: boolean;
     autoResetGlobalFilter?: boolean;
     enableGlobalFilter?: boolean;
-    globalFilterRowsFn?: (instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
+    getGlobalFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     getColumnCanGlobalFilterFn?: (column: Column<TGenerics>) => boolean;
 };
 export declare type FiltersInstance<TGenerics extends AnyGenerics> = {
@@ -74,6 +76,7 @@ export declare type FiltersInstance<TGenerics extends AnyGenerics> = {
     getPreFilteredRowModel: () => RowModel<TGenerics>;
     getPreColumnFilteredRowModel: () => RowModel<TGenerics>;
     getColumnFilteredRowModel: () => RowModel<TGenerics>;
+    _getColumnFilteredRowModel?: () => RowModel<TGenerics>;
     setGlobalFilter: (updater: Updater<any>) => void;
     resetGlobalFilter: () => void;
     getGlobalAutoFilterFn: () => FilterFn<TGenerics> | undefined;
@@ -81,6 +84,7 @@ export declare type FiltersInstance<TGenerics extends AnyGenerics> = {
     getColumnCanGlobalFilter: (columnId: string) => boolean;
     getPreGlobalFilteredRowModel: () => RowModel<TGenerics>;
     getGlobalFilteredRowModel: () => RowModel<TGenerics>;
+    _getGlobalFilteredRowModel?: () => RowModel<TGenerics>;
 };
 export declare const Filters: {
     getDefaultColumn: <TGenerics extends AnyGenerics>() => FiltersColumnDef<TGenerics>;

package/build/types/features/Grouping.d.ts

@@ -56,7 +56,7 @@ export declare type GroupingOptions<TGenerics extends AnyGenerics> = {
     autoResetGrouping?: boolean;
     enableGrouping?: boolean;
     enableGroupingRemoval?: boolean;
-    groupRowsFn?: (instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
+    getGroupedRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     groupedColumnMode?: false | 'reorder' | 'remove';
 };
 export declare type GroupingColumnMode = false | 'reorder' | 'remove';
@@ -78,6 +78,7 @@ export declare type GroupingInstance<TGenerics extends AnyGenerics> = {
     getRowIsGrouped: (rowId: string) => boolean;
     getPreGroupedRowModel: () => RowModel<TGenerics>;
     getGroupedRowModel: () => RowModel<TGenerics>;
+    _getGroupedRowModel?: () => RowModel<TGenerics>;
 };
 export declare const Grouping: {
     getDefaultColumn: <TGenerics extends AnyGenerics>() => GroupingColumnDef<TGenerics>;
@@ -87,5 +88,5 @@ export declare const Grouping: {
     getInstance: <TGenerics_3 extends AnyGenerics>(instance: TableInstance<TGenerics_3>) => GroupingInstance<TGenerics_3>;
     createRow: <TGenerics_4 extends AnyGenerics>(row: Row<TGenerics_4>, instance: TableInstance<TGenerics_4>) => GroupingRow;
     createCell: <TGenerics_5 extends AnyGenerics>(cell: Cell<TGenerics_5>, column: Column<TGenerics_5>, row: Row<TGenerics_5>, instance: TableInstance<TGenerics_5>) => GroupingCell<TGenerics_5>;
-    orderColumns: <TGenerics_6 extends AnyGenerics>(leafColumns: Column<TGenerics_6>[], grouping: string[], groupedColumnMode?: GroupingColumnMode | undefined) => Column<TGenerics_6>[];
+    orderColumns: <TGenerics_6 extends AnyGenerics>(leafColumns: Column<TGenerics_6>[], grouping: string[], groupedColumnMode?: GroupingColumnMode) => Column<TGenerics_6>[];
 };

package/build/types/features/Pagination.d.ts

@@ -10,7 +10,7 @@ export declare type PaginationTableState = {
 export declare type PaginationOptions<TGenerics extends AnyGenerics> = {
     onPaginationChange?: OnChangeFn<PaginationState>;
     autoResetPageIndex?: boolean;
-    paginateRowsFn?: (instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
+    getPaginationRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
 };
 export declare type PaginationDefaultOptions = {
     onPaginationChange: OnChangeFn<PaginationState>;
@@ -32,6 +32,7 @@ export declare type PaginationInstance<TGenerics extends AnyGenerics> = {
     nextPage: () => void;
     getPrePaginationRowModel: () => RowModel<TGenerics>;
     getPaginationRowModel: () => RowModel<TGenerics>;
+    _getPaginationRowModel?: () => RowModel<TGenerics>;
     getPageCount: () => number;
 };
 export declare const Pagination: {

package/build/types/features/Sorting.d.ts

@@ -49,7 +49,7 @@ export declare type SortingOptions<TGenerics extends AnyGenerics> = {
     enableMultiRemove?: boolean;
     enableMultiSort?: boolean;
     sortDescFirst?: boolean;
-    sortRowsFn?: (instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
+    getSortedRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     maxMultiSortColCount?: number;
     isMultiSortEvent?: (e: MouseEvent | TouchEvent) => boolean;
 };
@@ -72,6 +72,7 @@ export declare type SortingInstance<TGenerics extends AnyGenerics> = {
     getToggleSortingProps: <TGetter extends Getter<ToggleSortingProps>>(columnId: string, userProps?: TGetter) => undefined | PropGetterValue<ToggleSortingProps, TGetter>;
     getPreSortedRowModel: () => RowModel<TGenerics>;
     getSortedRowModel: () => RowModel<TGenerics>;
+    _getSortedRowModel?: () => RowModel<TGenerics>;
 };
 export declare const Sorting: {
     getDefaultColumn: <TGenerics extends AnyGenerics>() => SortingColumnDef<TGenerics>;

package/build/types/index.d.ts

@@ -15,9 +15,11 @@ export * from './features/Sorting';
 export * from './features/Visibility';
 export * from './features/Expanding';
 export * from './utils';
-export * from './utils/columnFilterRowsFn';
-export * from './utils/globalFilterRowsFn';
-export * from './utils/sortRowsFn';
-export * from './utils/groupRowsFn';
-export * from './utils/expandRowsFn';
-export * from './utils/paginateRowsFn';
+export * from './utils/getCoreRowModelSync';
+export * from './utils/getCoreRowModelAsync';
+export * from './utils/getColumnFilteredRowModelSync';
+export * from './utils/getGlobalFilteredRowModelSync';
+export * from './utils/getSortedRowModelSync';
+export * from './utils/getGroupedRowModel';
+export * from './utils/getExpandedRowModel';
+export * from './utils/getPaginationRowModel';

package/build/types/types.d.ts

@@ -1,4 +1,4 @@
-import { CoreColumn, CoreColumnDef, CoreOptions, CoreRow, TableCore } from './core';
+import { CoreColumn, CoreColumnDef, CoreOptions, CoreRow, CoreTableState, TableCore } from './core';
 import { VisibilityInstance, VisibilityTableState, VisibilityColumn as ColumnVisibilityColumn, VisibilityOptions, VisibilityColumnDef, VisibilityRow } from './features/Visibility';
 import { ColumnOrderInstance, ColumnOrderOptions, ColumnOrderTableState } from './features/Ordering';
 import { ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningTableState } from './features/Pinning';
@@ -40,7 +40,7 @@ export declare type TableInstance<TGenerics extends AnyGenerics> = TableCore<TGe
 export declare type Options<TGenerics extends AnyGenerics> = CoreOptions<TGenerics> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TGenerics> & SortingOptions<TGenerics> & GroupingOptions<TGenerics> & ExpandedOptions<TGenerics> & ColumnSizingOptions & PaginationOptions<TGenerics> & RowSelectionOptions<TGenerics>;
 export declare type Updater<T> = T | ((old: T) => T);
 export declare type OnChangeFn<T> = (updaterOrValue: Updater<T>, value: T) => void;
-export declare type TableState = VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationTableState & RowSelectionTableState;
+export declare type TableState = CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationTableState & RowSelectionTableState;
 export declare type Row<TGenerics extends AnyGenerics> = CoreRow<TGenerics> & VisibilityRow<TGenerics> & HeadersRow<TGenerics> & GroupingRow & RowSelectionRow & ExpandedRow;
 export declare type RowValues = {
     [key: string]: any;

package/build/types/utils/getColumnFilteredRowModelAsync.d.ts

@@ -0,0 +1,4 @@
+import { TableInstance, RowModel, AnyGenerics } from '../types';
+export declare function getColumnFilteredRowModelAsync<TGenerics extends AnyGenerics>(opts?: {
+    initialSync?: boolean;
+}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getColumnFilteredRowModelSync.d.ts

@@ -0,0 +1,2 @@
+import { TableInstance, RowModel, AnyGenerics } from '../types';
+export declare function getColumnFilteredRowModelSync<TGenerics extends AnyGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getCoreRowModelAsync.d.ts

@@ -0,0 +1,4 @@
+import { TableInstance, RowModel, AnyGenerics } from '../types';
+export declare function getCoreRowModelAsync<TGenerics extends AnyGenerics>(opts?: {
+    initialSync: boolean;
+}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getCoreRowModelSync.d.ts

@@ -0,0 +1,2 @@
+import { TableInstance, RowModel, AnyGenerics } from '../types';
+export declare function getCoreRowModelSync<TGenerics extends AnyGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getExpandedRowModel.d.ts

@@ -0,0 +1,7 @@
+import { TableInstance, Row, RowModel, AnyGenerics } from '../types';
+export declare function getExpandedRowModel<TGenerics extends AnyGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+export declare function expandRows<TGenerics extends AnyGenerics>(rowModel: RowModel<TGenerics>, instance: TableInstance<TGenerics>): {
+    rows: Row<TGenerics>[];
+    flatRows: Row<TGenerics>[];
+    rowsById: Record<string, Row<TGenerics>>;
+};

package/build/types/utils/getGlobalFilteredRowModelAsync.d.ts

@@ -0,0 +1,4 @@
+import { TableInstance, RowModel, AnyGenerics } from '../types';
+export declare function getGlobalFilteredRowModelAsync<TGenerics extends AnyGenerics>(opts?: {
+    initialSync?: boolean;
+}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getGlobalFilteredRowModelSync.d.ts

@@ -0,0 +1,2 @@
+import { TableInstance, RowModel, AnyGenerics } from '../types';
+export declare function getGlobalFilteredRowModelSync<TGenerics extends AnyGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getGroupedRowModel.d.ts

@@ -0,0 +1,2 @@
+import { TableInstance, RowModel, AnyGenerics } from '../types';
+export declare function getGroupedRowModelSync<TGenerics extends AnyGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getPaginationRowModel.d.ts

@@ -0,0 +1,4 @@
+import { TableInstance, RowModel, AnyGenerics } from '../types';
+export declare function getPaginationRowModel<TGenerics extends AnyGenerics>(opts?: {
+    initialSync: boolean;
+}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/{sortRowsQuicksortFn.d.ts → getSortedRowModelAsync.d.ts}

@@ -1,5 +1,7 @@
 import { TableInstance, Row, RowModel, AnyGenerics } from '../types';
-export declare function sortRowsFn<TGenerics extends AnyGenerics>(instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>): RowModel<TGenerics>;
+export declare function getSortedRowModelSync<TGenerics extends AnyGenerics>(opts?: {
+    initialSync?: boolean;
+}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
 declare type Sorter<TGenerics extends AnyGenerics> = {
     id: string;
     compare: (a: Row<TGenerics>, b: Row<TGenerics>) => number;

package/build/types/utils/getSortedRowModelSync.d.ts

@@ -0,0 +1,2 @@
+import { TableInstance, RowModel, AnyGenerics } from '../types';
+export declare function getSortedRowModelSync<TGenerics extends AnyGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils.d.ts

@@ -8,6 +8,11 @@ export declare type Overwrite<T, U extends {
 export declare type DataUpdateFunction<T> = (input: T) => T;
 export declare function functionalUpdate<T>(updater: Updater<T>, input: T): T;
 export declare function noop(): void;
+export declare function getBatchGroups<T>(arr: T[], count: number): {
+    start: number;
+    end: number;
+    items: T[];
+}[];
 export declare function makeStateUpdater(key: keyof TableState, instance: unknown): (updater: Updater<any>) => void;
 declare type AnyFunction = (...args: any) => any;
 export declare function isFunction<T extends AnyFunction>(d: any): d is T;
@@ -19,4 +24,15 @@ export declare function memo<TDeps extends readonly any[], TResult>(getDeps: ()
     debug?: () => any;
     onChange?: (result: TResult, previousResult?: TResult) => void;
 }): () => TResult;
+declare type WorkFn = () => void;
+export declare function incrementalMemo<TDeps extends readonly any[], TResult>(getDeps: () => [...TDeps], getInitialValue: (...args: NoInfer<[...TDeps]>) => TResult, schedule: (...args: NoInfer<[...TDeps]>) => (resultRef: {
+    current: TResult;
+}) => (scheduler: (workFn: WorkFn) => void) => void, opts: {
+    key: string;
+    onProgress: (progress: number, nextResult: TResult, result?: TResult) => void;
+    onChange: (result: TResult, previousResult?: TResult) => void;
+    initialSync?: boolean;
+    timeout?: number;
+    debug?: () => any;
+}): () => TResult;
 export {};