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

package/build/types/core.d.ts

@@ -1,8 +1,6 @@
 import { RequiredKeys } from './utils';
 import { Updater, TableOptions, TableState, TableInstance, Renderable, TableFeature, TableGenerics, InitialTableState } from './types';
-export declare type CoreTableState = {
-    coreProgress: number;
-};
+export declare type CoreTableState = {};
 export declare type CoreOptions<TGenerics extends TableGenerics> = {
     data: TGenerics['Row'][];
     state: Partial<TableState>;
@@ -16,9 +14,10 @@ export declare type CoreOptions<TGenerics extends TableGenerics> = {
     initialState?: InitialTableState;
     autoResetAll?: boolean;
     mergeOptions?: <T>(defaultOptions: T, options: Partial<T>) => T;
+    keepPreviousData?: boolean;
     meta?: TGenerics['TableMeta'];
 };
-export declare type TableCore<TGenerics extends TableGenerics> = {
+export declare type CoreInstance<TGenerics extends TableGenerics> = {
     initialState: TableState;
     reset: () => void;
     options: RequiredKeys<TableOptions<TGenerics>, 'state'>;
@@ -27,7 +26,6 @@ export declare type TableCore<TGenerics extends TableGenerics> = {
     getState: () => TableState;
     setState: (updater: Updater<TableState>) => void;
     render: <TProps>(template: Renderable<TGenerics, TProps>, props: TProps) => string | null | TGenerics['Rendered'];
-    getOverallProgress: () => number;
     _features: readonly TableFeature[];
 };
 export declare function createTableInstance<TGenerics extends TableGenerics>(options: TableOptions<TGenerics>): TableInstance<TGenerics>;

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

@@ -4,7 +4,7 @@ export declare type CellsRow<TGenerics extends TableGenerics> = {
     getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>;
 };
 export declare type CellsInstance<TGenerics extends TableGenerics> = {
-    createCell: (row: Row<TGenerics>, column: Column<TGenerics>, value: any) => Cell<TGenerics>;
+    createCell: (row: Row<TGenerics>, column: Column<TGenerics>, columnId: string) => Cell<TGenerics>;
     getCell: (rowId: string, columnId: string) => Cell<TGenerics>;
 };
 export declare const Cells: {

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

@@ -26,19 +26,10 @@ export declare type ColumnSizingDefaultOptions = {
     onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
 };
 export declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
-    getColumnSize: (columnId: string) => number;
-    getColumnStart: (columnId: string, position?: ColumnPinningPosition) => number;
     setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
     setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
     resetColumnSizing: () => void;
-    resetColumnSize: (columnId: string) => void;
-    resetHeaderSize: (headerId: string) => void;
     resetHeaderSizeInfo: () => void;
-    getColumnCanResize: (columnId: string) => boolean;
-    getHeaderCanResize: (headerId: string) => boolean;
-    getResizeHandler: (headerId: string) => (event: unknown) => void;
-    getColumnIsResizing: (columnId: string) => boolean;
-    getHeaderIsResizing: (headerId: string) => boolean;
     getTotalSize: () => number;
     getLeftTotalSize: () => number;
     getCenterTotalSize: () => number;
@@ -46,7 +37,6 @@ export declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
 };
 export declare type ColumnSizingColumnDef = {
     enableResizing?: boolean;
-    defaultCanResize?: boolean;
     size?: number;
     minSize?: number;
     maxSize?: number;
@@ -59,10 +49,9 @@ export declare type ColumnSizingColumn<TGenerics extends TableGenerics> = {
     resetSize: () => void;
 };
 export declare type ColumnSizingHeader<TGenerics extends TableGenerics> = {
-    getCanResize: () => boolean;
-    getIsResizing: () => boolean;
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
     getResizeHandler: () => (event: unknown) => void;
-    resetSize: () => void;
 };
 export declare const defaultColumnSizing: {
     size: number;

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

@@ -20,7 +20,7 @@ export declare type CoreColumnDef<TGenerics extends TableGenerics> = {
         row: Row<TGenerics>;
         column: Column<TGenerics>;
         cell: Cell<TGenerics>;
-        value: TGenerics['Value'];
+        getValue: () => TGenerics['Value'];
     }>;
     meta?: TGenerics['ColumnMeta'];
 };

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

@@ -15,10 +15,9 @@ export declare type ExpandedOptions<TGenerics extends TableGenerics> = {
     manualExpanding?: boolean;
     onExpandedChange?: OnChangeFn<ExpandedState>;
     autoResetExpanded?: boolean;
-    enableExpanded?: boolean;
+    enableExpanding?: boolean;
     getExpandedRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     expandSubRows?: boolean;
-    defaultCanExpand?: boolean;
     getIsRowExpanded?: (row: Row<TGenerics>) => boolean;
     getRowCanExpand?: (row: Row<TGenerics>) => boolean;
     paginateExpandedRows?: boolean;
@@ -26,13 +25,9 @@ export declare type ExpandedOptions<TGenerics extends TableGenerics> = {
 export declare type ExpandedInstance<TGenerics extends TableGenerics> = {
     _autoResetExpanded: () => void;
     setExpanded: (updater: Updater<ExpandedState>) => void;
-    toggleRowExpanded: (rowId: string, expanded?: boolean) => void;
     toggleAllRowsExpanded: (expanded?: boolean) => void;
     resetExpanded: () => void;
-    getRowCanExpand: (rowId: string) => boolean;
     getCanSomeRowsExpand: () => boolean;
-    getIsRowExpanded: (rowId: string) => boolean;
-    getToggleExpandedHandler: (rowId: string) => undefined | (() => void);
     getToggleAllRowsExpandedHandler: () => (event: unknown) => void;
     getIsSomeRowsExpanded: () => boolean;
     getIsAllRowsExpanded: () => boolean;

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

@@ -5,19 +5,24 @@ import { Overwrite } from '../utils';
 export declare type FiltersTableState = {
     columnFilters: ColumnFiltersState;
     globalFilter: any;
-    columnFiltersProgress: number;
-    globalFilterProgress: number;
 };
 export declare type ColumnFiltersState = ColumnFilter[];
 export declare type ColumnFilter = {
     id: string;
     value: unknown;
 };
+export declare type ResolvedColumnFilter<TGenerics extends TableGenerics> = {
+    id: string;
+    resolvedValue: unknown;
+    filterFn: FilterFn<TGenerics>;
+};
 export declare type FilterFn<TGenerics extends TableGenerics> = {
-    (rows: Row<TGenerics>[], columnIds: string[], filterValue: any): any;
+    (row: Row<TGenerics>, columnId: string, filterValue: any): boolean;
+    resolveFilterValue?: TransformFilterValueFn<TGenerics>;
     autoRemove?: ColumnFilterAutoRemoveTestFn<TGenerics>;
 };
-export declare type ColumnFilterAutoRemoveTestFn<TGenerics extends TableGenerics> = (value: unknown, column?: Column<TGenerics>) => boolean;
+export declare type TransformFilterValueFn<TGenerics extends TableGenerics> = (value: any, column?: Column<TGenerics>) => unknown;
+export declare type ColumnFilterAutoRemoveTestFn<TGenerics extends TableGenerics> = (value: any, column?: Column<TGenerics>) => boolean;
 export declare type CustomFilterFns<TGenerics extends TableGenerics> = Record<string, FilterFn<TGenerics>>;
 export declare type FilterFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInFilterFn | keyof TGenerics['FilterFns'] | FilterFn<TGenerics>;
 export declare type FiltersColumnDef<TGenerics extends TableGenerics> = {
@@ -26,56 +31,63 @@ export declare type FiltersColumnDef<TGenerics extends TableGenerics> = {
     }>>;
     enableColumnFilter?: boolean;
     enableGlobalFilter?: boolean;
+    enableFaceting?: boolean;
 };
 export declare type FiltersColumn<TGenerics extends TableGenerics> = {
     filterFn: FilterFnOption<Overwrite<TGenerics, {
         Value: any;
     }>>;
-    getCanColumnFilter: () => boolean;
+    getAutoFilterFn: () => FilterFn<TGenerics> | undefined;
+    getFilterFn: () => FilterFn<TGenerics> | undefined;
+    setFilterValue: (updater: Updater<any>) => void;
+    getCanFilter: () => boolean;
     getCanGlobalFilter: () => boolean;
-    getColumnFilterIndex: () => number;
-    getColumnIsFiltered: () => boolean;
-    getColumnFilterValue: () => unknown;
-    setColumnFilterValue: (updater: Updater<any>) => void;
-    getPreFilteredRows: () => Row<TGenerics>[] | undefined;
-    getPreFilteredUniqueValues: () => Map<any, number>;
-    getPreFilteredMinMaxValues: () => [any, any];
+    getFacetedRowModel: () => RowModel<TGenerics>;
+    _getFacetedRowModel?: () => RowModel<TGenerics>;
+    getIsFiltered: () => boolean;
+    getFilterValue: () => unknown;
+    getFilterIndex: () => number;
+    getFacetedUniqueValues: () => Map<any, number>;
+    _getFacetedUniqueValues?: () => Map<any, number>;
+    getFacetedMinMaxValues: () => [any, any];
+    _getFacetedMinMaxValues?: () => [any, any];
+};
+export declare type FiltersRow<TGenerics extends TableGenerics> = {
+    columnFilterMap: Record<string, boolean>;
+    subRowsByFacetId: Record<string, Row<TGenerics>[]>;
 };
 export declare type FiltersOptions<TGenerics extends TableGenerics> = {
+    enableFilters?: boolean;
+    manualFiltering?: boolean;
     filterFromLeafRows?: boolean;
     filterFns?: TGenerics['FilterFns'];
-    manualColumnFiltering?: boolean;
+    getFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
     enableColumnFilters?: boolean;
-    getColumnFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
-    manualGlobalFiltering?: boolean;
     globalFilterFn?: FilterFnOption<TGenerics>;
     onGlobalFilterChange?: OnChangeFn<any>;
     enableGlobalFilter?: boolean;
-    getGlobalFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     getColumnCanGlobalFilter?: (column: Column<TGenerics>) => boolean;
+    getFacetedRowModel?: (instance: TableInstance<TGenerics>, columnId: string) => () => RowModel<TGenerics>;
+    getFacetedUniqueValues?: (instance: TableInstance<TGenerics>, columnId: string) => () => Map<any, number>;
+    getFacetedMinMaxValues?: (instance: TableInstance<TGenerics>, columnId: string) => () => [number, number];
 };
 export declare type FiltersInstance<TGenerics extends TableGenerics> = {
-    getColumnAutoFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined;
-    getColumnFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined;
     setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
-    setColumnFilterValue: (columnId: string, updater: Updater<any>) => void;
     resetColumnFilters: () => void;
-    getColumnCanColumnFilter: (columnId: string) => boolean;
-    getColumnIsFiltered: (columnId: string) => boolean;
-    getColumnFilterValue: (columnId: string) => unknown;
-    getColumnFilterIndex: (columnId: string) => number;
-    getPreColumnFilteredRowModel: () => RowModel<TGenerics>;
-    getColumnFilteredRowModel: () => RowModel<TGenerics>;
-    _getColumnFilteredRowModel?: () => RowModel<TGenerics>;
+    getPreFilteredRowModel: () => RowModel<TGenerics>;
+    getFilteredRowModel: () => RowModel<TGenerics>;
+    _getFilteredRowModel?: () => RowModel<TGenerics>;
     setGlobalFilter: (updater: Updater<any>) => void;
     resetGlobalFilter: () => void;
     getGlobalAutoFilterFn: () => FilterFn<TGenerics> | undefined;
     getGlobalFilterFn: () => FilterFn<TGenerics> | undefined;
-    getColumnCanGlobalFilter: (columnId: string) => boolean;
-    getPreGlobalFilteredRowModel: () => RowModel<TGenerics>;
-    getGlobalFilteredRowModel: () => RowModel<TGenerics>;
-    _getGlobalFilteredRowModel?: () => RowModel<TGenerics>;
+    getGlobalFacetedRowModel: () => RowModel<TGenerics>;
+    _getGlobalFacetedRowModel?: () => RowModel<TGenerics>;
+    getGlobalFacetedUniqueValues: () => Map<any, number>;
+    _getGlobalFacetedUniqueValues?: () => Map<any, number>;
+    getGlobalFacetedMinMaxValues: () => [number, number];
+    _getGlobalFacetedMinMaxValues?: () => [number, number];
 };
 export declare const Filters: TableFeature;
 export declare function shouldAutoRemoveFilter<TGenerics extends TableGenerics>(filterFn?: FilterFn<TGenerics>, value?: any, column?: Column<TGenerics>): boolean;

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

@@ -19,10 +19,9 @@ export declare type GroupingColumnDef<TGenerics extends TableGenerics> = {
         row: Row<TGenerics>;
         column: Column<TGenerics>;
         cell: Cell<TGenerics>;
-        value: TGenerics['Value'];
+        getValue: () => TGenerics['Value'];
     }>;
     enableGrouping?: boolean;
-    defaultCanGroup?: boolean;
 };
 export declare type GroupingColumn<TGenerics extends TableGenerics> = {
     aggregationFn?: AggregationFnOption<Overwrite<TGenerics, {
@@ -33,11 +32,14 @@ export declare type GroupingColumn<TGenerics extends TableGenerics> = {
     getGroupedIndex: () => number;
     toggleGrouping: () => void;
     getToggleGroupingHandler: () => () => void;
+    getColumnAutoAggregationFn: () => AggregationFn<TGenerics> | undefined;
+    getColumnAggregationFn: () => AggregationFn<TGenerics> | undefined;
 };
 export declare type GroupingRow = {
     groupingColumnId?: string;
     groupingValue?: any;
     getIsGrouped: () => boolean;
+    groupingValuesCache: Record<string, any>;
 };
 export declare type GroupingCell<TGenerics extends TableGenerics> = {
     getIsGrouped: () => boolean;
@@ -60,16 +62,8 @@ export declare type GroupingOptions<TGenerics extends TableGenerics> = {
 };
 export declare type GroupingColumnMode = false | 'reorder' | 'remove';
 export declare type GroupingInstance<TGenerics extends TableGenerics> = {
-    getColumnAutoAggregationFn: (columnId: string) => AggregationFn<TGenerics> | undefined;
-    getColumnAggregationFn: (columnId: string) => AggregationFn<TGenerics> | undefined;
     setGrouping: (updater: Updater<GroupingState>) => void;
     resetGrouping: () => void;
-    toggleColumnGrouping: (columnId: string) => void;
-    getColumnCanGroup: (columnId: string) => boolean;
-    getColumnIsGrouped: (columnId: string) => boolean;
-    getColumnGroupedIndex: (columnId: string) => number;
-    getToggleGroupingHandler: (columnId: string) => undefined | (() => void);
-    getRowIsGrouped: (rowId: string) => boolean;
     getPreGroupedRowModel: () => RowModel<TGenerics>;
     getGroupedRowModel: () => RowModel<TGenerics>;
     _getGroupedRowModel?: () => RowModel<TGenerics>;

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

@@ -31,10 +31,6 @@ export declare type ColumnPinningRow<TGenerics extends TableGenerics> = {
 export declare type ColumnPinningInstance<TGenerics extends TableGenerics> = {
     setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
     resetColumnPinning: () => void;
-    pinColumn: (columnId: string, position: ColumnPinningPosition) => void;
-    getColumnCanPin: (columnId: string) => boolean;
-    getColumnIsPinned: (columnId: string) => ColumnPinningPosition;
-    getColumnPinnedIndex: (columnId: string) => number;
     getIsSomeColumnsPinned: () => boolean;
     getLeftLeafColumns: () => Column<TGenerics>[];
     getRightLeafColumns: () => Column<TGenerics>[];

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

@@ -14,21 +14,15 @@ export declare type RowSelectionRow = {
     getIsSomeSelected: () => boolean;
     getCanSelect: () => boolean;
     getCanMultiSelect: () => boolean;
+    getCanSelectSubRows: () => boolean;
     toggleSelected: (value?: boolean) => void;
     getToggleSelectedHandler: () => (event: unknown) => void;
 };
 export declare type RowSelectionInstance<TGenerics extends TableGenerics> = {
-    getToggleRowSelectedHandler: (rowId: string) => undefined | ((e: unknown) => void);
     getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
     getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
     setRowSelection: (updater: Updater<RowSelectionState>) => void;
     resetRowSelection: () => void;
-    toggleRowSelected: (rowId: string, value?: boolean) => void;
-    getRowCanSelect: (rowId: string) => boolean;
-    getRowCanSelectSubRows: (rowId: string) => boolean;
-    getRowCanMultiSelect: (rowId: string) => boolean;
-    getRowIsSelected: (rowId: string) => boolean;
-    getRowIsSomeSelected: (rowId: string) => boolean;
     getIsAllRowsSelected: () => boolean;
     getIsAllPageRowsSelected: () => boolean;
     getIsSomeRowsSelected: () => boolean;

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

@@ -1,10 +1,11 @@
-import { TableGenerics, TableInstance, Row, RowModel, RowValues } from '../types';
+import { TableGenerics, TableInstance, Row, RowModel } from '../types';
 export declare type CoreRow<TGenerics extends TableGenerics> = {
     id: string;
     index: number;
     original?: TGenerics['Row'];
     depth: number;
-    values: RowValues;
+    valuesCache: Record<string, any>;
+    getValue: (columnId: string) => any;
     subRows: Row<TGenerics>[];
     getLeafRows: () => Row<TGenerics>[];
     originalSubRows?: TGenerics['Row'][];
@@ -16,7 +17,7 @@ export declare type RowsOptions<TGenerics extends TableGenerics> = {
 };
 export declare type RowsInstance<TGenerics extends TableGenerics> = {
     getRowId: (_: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
-    createRow: (id: string, original: TGenerics['Row'] | undefined, rowIndex: number, depth: number, values: Record<string, any>) => Row<TGenerics>;
+    createRow: (id: string, original: TGenerics['Row'] | undefined, rowIndex: number, depth: number, subRows?: Row<TGenerics>[]) => Row<TGenerics>;
     getCoreRowModel: () => RowModel<TGenerics>;
     _getCoreRowModel?: () => RowModel<TGenerics>;
     getRowModel: () => RowModel<TGenerics>;

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

@@ -23,14 +23,13 @@ export declare type SortingColumnDef<TGenerics extends TableGenerics> = {
     sortDescFirst?: boolean;
     enableSorting?: boolean;
     enableMultiSort?: boolean;
-    defaultCanSort?: boolean;
     invertSorting?: boolean;
     sortUndefined?: false | -1 | 1;
 };
 export declare type SortingColumn<TGenerics extends TableGenerics> = {
-    sortingFn: SortingFnOption<Overwrite<TGenerics, {
-        Value: any;
-    }>>;
+    getAutoSortingFn: () => SortingFn<TGenerics>;
+    getAutoSortDir: () => SortDirection;
+    getSortingFn: () => SortingFn<TGenerics>;
     getCanSort: () => boolean;
     getCanMultiSort: () => boolean;
     getSortIndex: () => number;
@@ -53,17 +52,7 @@ export declare type SortingOptions<TGenerics extends TableGenerics> = {
     isMultiSortEvent?: (e: unknown) => boolean;
 };
 export declare type SortingInstance<TGenerics extends TableGenerics> = {
-    getColumnAutoSortingFn: (columnId: string) => SortingFn<TGenerics> | undefined;
-    getColumnAutoSortDir: (columnId: string) => SortDirection;
-    getColumnSortingFn: (columnId: string) => SortingFn<TGenerics> | undefined;
     setSorting: (updater: Updater<SortingState>) => void;
-    toggleColumnSorting: (columnId: string, desc?: boolean, multi?: boolean) => void;
-    resetSorting: (columnId?: string) => void;
-    getColumnCanSort: (columnId: string) => boolean;
-    getColumnCanMultiSort: (columnId: string) => boolean;
-    getColumnIsSorted: (columnId: string) => false | 'asc' | 'desc';
-    getColumnSortIndex: (columnId: string) => number;
-    getToggleSortingHandler: (columnId: string) => undefined | ((event: unknown) => void);
     getPreSortedRowModel: () => RowModel<TGenerics>;
     getSortedRowModel: () => RowModel<TGenerics>;
     _getSortedRowModel?: () => RowModel<TGenerics>;

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

@@ -17,17 +17,13 @@ export declare type VisibilityInstance<TGenerics extends TableGenerics> = {
     getRightVisibleLeafColumns: () => Column<TGenerics>[];
     getCenterVisibleLeafColumns: () => Column<TGenerics>[];
     setColumnVisibility: (updater: Updater<VisibilityState>) => void;
-    toggleColumnVisibility: (columnId: string, value?: boolean) => void;
     toggleAllColumnsVisible: (value?: boolean) => void;
-    getColumnIsVisible: (columId: string) => boolean;
-    getColumnCanHide: (columnId: string) => boolean;
     getIsAllColumnsVisible: () => boolean;
     getIsSomeColumnsVisible: () => boolean;
     getToggleAllColumnsVisibilityHandler: () => undefined | ((event: unknown) => void);
 };
 export declare type VisibilityColumnDef = {
     enableHiding?: boolean;
-    defaultCanHide?: boolean;
     defaultIsVisible?: boolean;
 };
 export declare type VisibilityRow<TGenerics extends TableGenerics> = {

package/build/types/filterFns.d.ts

@@ -1,55 +1,13 @@
-import { TableGenerics, Row } from './types';
+import { FilterFn } from './features/Filters';
 export declare const filterFns: {
-    includesString: typeof includesString;
-    includesStringSensitive: typeof includesStringSensitive;
-    equalsString: typeof equalsString;
-    equalsStringSensitive: typeof equalsStringSensitive;
-    arrIncludes: typeof arrIncludes;
-    arrIncludesAll: typeof arrIncludesAll;
-    arrIncludesSome: typeof arrIncludesSome;
-    equals: typeof equals;
-    weakEquals: typeof weakEquals;
-    betweenNumberRange: typeof betweenNumberRange;
+    includesString: FilterFn<any>;
+    includesStringSensitive: FilterFn<any>;
+    equalsString: FilterFn<any>;
+    arrIncludes: FilterFn<any>;
+    arrIncludesAll: FilterFn<any>;
+    arrIncludesSome: FilterFn<any>;
+    equals: FilterFn<any>;
+    weakEquals: FilterFn<any>;
+    inNumberRange: FilterFn<any>;
 };
 export declare type BuiltInFilterFn = keyof typeof filterFns;
-declare function includesString<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown): Row<TGenerics>[];
-declare namespace includesString {
-    var autoRemove: (val: any) => boolean;
-}
-declare function includesStringSensitive<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown): Row<TGenerics>[];
-declare namespace includesStringSensitive {
-    var autoRemove: (val: any) => boolean;
-}
-declare function equalsString<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown): Row<TGenerics>[];
-declare namespace equalsString {
-    var autoRemove: (val: any) => boolean;
-}
-declare function equalsStringSensitive<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown): Row<TGenerics>[];
-declare namespace equalsStringSensitive {
-    var autoRemove: (val: any) => boolean;
-}
-declare function arrIncludes<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown): Row<TGenerics>[];
-declare namespace arrIncludes {
-    var autoRemove: (val: any) => boolean;
-}
-declare function arrIncludesAll<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown[]): Row<TGenerics>[];
-declare namespace arrIncludesAll {
-    var autoRemove: (val: any) => boolean;
-}
-declare function arrIncludesSome<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown[]): Row<TGenerics>[];
-declare namespace arrIncludesSome {
-    var autoRemove: (val: any) => boolean;
-}
-declare function equals<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown): Row<TGenerics>[];
-declare namespace equals {
-    var autoRemove: (val: any) => boolean;
-}
-declare function weakEquals<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown): Row<TGenerics>[];
-declare namespace weakEquals {
-    var autoRemove: (val: any) => boolean;
-}
-declare function betweenNumberRange<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: [unknown, unknown]): Row<TGenerics>[];
-declare namespace betweenNumberRange {
-    var autoRemove: (val: any) => boolean;
-}
-export {};

package/build/types/index.d.ts

@@ -15,11 +15,12 @@ export * from './features/Sorting';
 export * from './features/Visibility';
 export * from './features/Expanding';
 export * from './utils';
-export * from './utils/getCoreRowModelSync';
-export * from './utils/getCoreRowModelAsync';
-export * from './utils/getColumnFilteredRowModelSync';
-export * from './utils/getGlobalFilteredRowModelSync';
-export * from './utils/getSortedRowModelSync';
+export * from './utils/getCoreRowModel';
+export * from './utils/getFilteredRowModel';
+export * from './utils/getFacetedRowModel';
+export * from './utils/getFacetedUniqueValues';
+export * from './utils/getFacetedMinMaxValues';
+export * from './utils/getSortedRowModel';
 export * from './utils/getGroupedRowModel';
 export * from './utils/getExpandedRowModel';
 export * from './utils/getPaginationRowModel';

package/build/types/types.d.ts

@@ -1,10 +1,10 @@
-import { CoreOptions, CoreTableState, TableCore } from './core';
+import { CoreOptions, CoreTableState, CoreInstance } from './core';
 import { ColumnsOptions, CoreColumn, CoreColumnDef } from './features/Columns';
 import { VisibilityInstance, VisibilityTableState, VisibilityColumn as ColumnVisibilityColumn, VisibilityOptions, VisibilityColumnDef, VisibilityRow } from './features/Visibility';
 import { ColumnOrderInstance, ColumnOrderOptions, ColumnOrderTableState } from './features/Ordering';
 import { ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningRow, ColumnPinningTableState } from './features/Pinning';
 import { HeadersInstance } from './features/Headers';
-import { FiltersColumn, FiltersColumnDef, FiltersInstance, FiltersOptions, FiltersTableState } from './features/Filters';
+import { FiltersColumn, FiltersColumnDef, FiltersInstance, FiltersOptions, FiltersRow, FiltersTableState } from './features/Filters';
 import { SortingColumn, SortingColumnDef, SortingInstance, SortingOptions, SortingTableState } from './features/Sorting';
 import { GroupingCell, GroupingColumn, GroupingColumnDef, GroupingInstance, GroupingOptions, GroupingRow, GroupingTableState } from './features/Grouping';
 import { ExpandedInstance, ExpandedOptions, ExpandedTableState, ExpandedRow } from './features/Expanding';
@@ -38,11 +38,11 @@ export declare type TableFeature = {
     createCell?: (cell: any, column: any, row: any, instance: any) => any;
     createRow?: (row: any, instance: any) => any;
 };
-export declare type TableInstance<TGenerics extends TableGenerics> = TableCore<TGenerics> & ColumnsInstance<TGenerics> & RowsInstance<TGenerics> & CellsInstance<TGenerics> & VisibilityInstance<TGenerics> & ColumnOrderInstance<TGenerics> & ColumnPinningInstance<TGenerics> & HeadersInstance<TGenerics> & FiltersInstance<TGenerics> & SortingInstance<TGenerics> & GroupingInstance<TGenerics> & ColumnSizingInstance<TGenerics> & ExpandedInstance<TGenerics> & PaginationInstance<TGenerics> & RowSelectionInstance<TGenerics>;
+export declare type TableInstance<TGenerics extends TableGenerics> = CoreInstance<TGenerics> & ColumnsInstance<TGenerics> & RowsInstance<TGenerics> & CellsInstance<TGenerics> & VisibilityInstance<TGenerics> & ColumnOrderInstance<TGenerics> & ColumnPinningInstance<TGenerics> & HeadersInstance<TGenerics> & FiltersInstance<TGenerics> & SortingInstance<TGenerics> & GroupingInstance<TGenerics> & ColumnSizingInstance<TGenerics> & ExpandedInstance<TGenerics> & PaginationInstance<TGenerics> & RowSelectionInstance<TGenerics>;
 export declare type TableOptions<TGenerics extends TableGenerics> = CoreOptions<TGenerics> & ColumnsOptions<TGenerics> & RowsOptions<TGenerics> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TGenerics> & SortingOptions<TGenerics> & GroupingOptions<TGenerics> & ExpandedOptions<TGenerics> & ColumnSizingOptions & PaginationOptions<TGenerics> & RowSelectionOptions<TGenerics>;
 export declare type TableState = CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationTableState & RowSelectionTableState;
 export declare type InitialTableState = Partial<CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationInitialTableState & RowSelectionTableState>;
-export declare type Row<TGenerics extends TableGenerics> = CoreRow<TGenerics> & CellsRow<TGenerics> & VisibilityRow<TGenerics> & ColumnPinningRow<TGenerics> & GroupingRow & RowSelectionRow & ExpandedRow;
+export declare type Row<TGenerics extends TableGenerics> = CoreRow<TGenerics> & CellsRow<TGenerics> & VisibilityRow<TGenerics> & ColumnPinningRow<TGenerics> & FiltersRow<TGenerics> & GroupingRow & RowSelectionRow & ExpandedRow;
 export declare type RowValues = {
     [key: string]: any;
 };
@@ -60,7 +60,7 @@ export declare type CoreCell<TGenerics extends TableGenerics> = {
     id: string;
     rowId: string;
     columnId: string;
-    value: TGenerics['Value'];
+    getValue: () => TGenerics['Value'];
     row: Row<TGenerics>;
     column: Column<TGenerics>;
     renderCell: () => string | null | TGenerics['Rendered'];
@@ -71,8 +71,6 @@ export declare type CoreHeader<TGenerics extends TableGenerics> = {
     index: number;
     depth: number;
     column: Column<TGenerics>;
-    getStart: () => number;
-    getSize: () => number;
     headerGroup: HeaderGroup<TGenerics>;
     subHeaders: Header<TGenerics>[];
     colSpan?: number;
@@ -92,14 +90,4 @@ export declare type HeaderGroup<TGenerics extends TableGenerics> = {
     depth: number;
     headers: Header<TGenerics>[];
 };
-export declare type HeaderRenderProps<THeader> = {
-    header: THeader;
-};
-export declare type FooterRenderProps<THeader> = {
-    header: THeader;
-};
-export declare type CellRenderProps<TCell, TRow> = {
-    cell: TCell;
-    row: TRow;
-};
 export declare type NoInfer<A extends any> = [A][A extends any ? 0 : never];

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

@@ -1,3 +1,4 @@
 import { TableGenerics, Row, RowModel, TableInstance } from '../types';
-export declare function filterRowModelFromLeafs<TGenerics extends TableGenerics>(rowsToFilter: Row<TGenerics>[], filterRows: (rowsToFilter: Row<TGenerics>[], depth: number) => Row<TGenerics>[], instance: TableInstance<TGenerics>): RowModel<TGenerics>;
-export declare function filterRowModelFromRoot<TGenerics extends TableGenerics>(rowsToFilter: Row<TGenerics>[], filterRows: (rowsToFilter: Row<TGenerics>[], depth: number) => Row<TGenerics>[], instance: TableInstance<TGenerics>): RowModel<TGenerics>;
+export declare function filterRows<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], filterRowImpl: (row: Row<TGenerics>) => any, instance: TableInstance<TGenerics>): RowModel<TGenerics>;
+export declare function filterRowModelFromLeafs<TGenerics extends TableGenerics>(rowsToFilter: Row<TGenerics>[], filterRow: (row: Row<TGenerics>) => Row<TGenerics>[], instance: TableInstance<TGenerics>): RowModel<TGenerics>;
+export declare function filterRowModelFromRoot<TGenerics extends TableGenerics>(rowsToFilter: Row<TGenerics>[], filterRow: (row: Row<TGenerics>) => any, instance: TableInstance<TGenerics>): RowModel<TGenerics>;

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

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

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

@@ -0,0 +1,2 @@
+import { TableInstance, TableGenerics } from '../types';
+export declare function getFacetedMinMaxValues<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => [number, number];

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

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

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

@@ -0,0 +1,2 @@
+import { TableInstance, TableGenerics } from '../types';
+export declare function getFacetedUniqueValues<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => Map<any, number>;

package/build/types/utils/{getCoreRowModelSync.d.ts → getFilteredRowModel.d.ts}

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

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

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

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

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

package/build/types/utils.d.ts

@@ -7,29 +7,13 @@ export declare type Overwrite<T, U extends {
 export declare type IfDefined<T, N> = 0 extends 1 & T ? N : T extends {} ? T : N;
 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;
 export declare function flattenBy<TNode>(arr: TNode[], getChildren: (item: TNode) => TNode[]): TNode[];
 export declare function memo<TDeps extends readonly any[], TResult>(getDeps: () => [...TDeps], fn: (...args: NoInfer<[...TDeps]>) => TResult, opts: {
-    key: string;
-    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;
+    key: any;
     debug?: () => any;
+    onChange?: (result: TResult) => void;
 }): () => TResult;
 export {};