@tanstack/table-core 8.0.7 → 8.0.12

package/build/types/aggregationFns.d.ts

@@ -0,0 +1,13 @@
+import { AggregationFn } from './features/Grouping';
+export declare const aggregationFns: {
+    sum: AggregationFn<any>;
+    min: AggregationFn<any>;
+    max: AggregationFn<any>;
+    extent: AggregationFn<any>;
+    mean: AggregationFn<any>;
+    median: AggregationFn<any>;
+    unique: AggregationFn<any>;
+    uniqueCount: AggregationFn<any>;
+    count: AggregationFn<any>;
+};
+export declare type BuiltInAggregationFn = keyof typeof aggregationFns;

package/build/types/core/cell.d.ts

@@ -0,0 +1,9 @@
+import { Cell, Column, Row, TableGenerics, TableInstance } from '../types';
+export declare type CoreCell<TGenerics extends TableGenerics> = {
+    id: string;
+    getValue: () => TGenerics['Value'];
+    row: Row<TGenerics>;
+    column: Column<TGenerics>;
+    renderCell: () => string | null | TGenerics['Rendered'];
+};
+export declare function createCell<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, row: Row<TGenerics>, column: Column<TGenerics>, columnId: string): Cell<TGenerics>;

package/build/types/core/column.d.ts

@@ -0,0 +1,40 @@
+import { Cell, Column, Header, TableGenerics, TableInstance, Row, AccessorFn, ColumnDef, Renderable } from '../types';
+export declare type CoreColumnDefType = 'data' | 'display' | 'group';
+export declare type CoreColumnDef<TGenerics extends TableGenerics> = {
+    id: string;
+    accessorKey?: string & keyof TGenerics['Row'];
+    accessorFn?: AccessorFn<TGenerics['Row']>;
+    columns?: ColumnDef<TGenerics>[];
+    header?: Renderable<TGenerics, {
+        instance: TableInstance<TGenerics>;
+        header: Header<TGenerics>;
+        column: Column<TGenerics>;
+    }>;
+    footer?: Renderable<TGenerics, {
+        instance: TableInstance<TGenerics>;
+        header: Header<TGenerics>;
+        column: Column<TGenerics>;
+    }>;
+    cell?: Renderable<TGenerics, {
+        instance: TableInstance<TGenerics>;
+        row: Row<TGenerics>;
+        column: Column<TGenerics>;
+        cell: Cell<TGenerics>;
+        getValue: () => TGenerics['Value'];
+    }>;
+    meta?: TGenerics['ColumnMeta'];
+};
+export declare type CoreColumn<TGenerics extends TableGenerics> = {
+    id: string;
+    depth: number;
+    accessorFn?: AccessorFn<TGenerics['Row']>;
+    columnDef: ColumnDef<TGenerics>;
+    columnDefType: CoreColumnDefType;
+    columns: Column<TGenerics>[];
+    parent?: Column<TGenerics>;
+    getFlatColumns: () => Column<TGenerics>[];
+    getLeafColumns: () => Column<TGenerics>[];
+};
+export declare function createColumn<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, columnDef: ColumnDef<TGenerics> & {
+    columnDefType?: CoreColumnDefType;
+}, depth: number, parent?: Column<TGenerics>): Column<TGenerics>;

package/build/types/core/headers.d.ts

@@ -0,0 +1,46 @@
+import { Column, Header, HeaderGroup, TableGenerics, TableInstance } from '../types';
+import { TableFeature } from './instance';
+export declare type CoreHeaderGroup<TGenerics extends TableGenerics> = {
+    id: string;
+    depth: number;
+    headers: Header<TGenerics>[];
+};
+export declare type CoreHeader<TGenerics extends TableGenerics> = {
+    id: string;
+    index: number;
+    depth: number;
+    column: Column<TGenerics>;
+    headerGroup: HeaderGroup<TGenerics>;
+    subHeaders: Header<TGenerics>[];
+    colSpan: number;
+    rowSpan: number;
+    getLeafHeaders: () => Header<TGenerics>[];
+    isPlaceholder: boolean;
+    placeholderId?: string;
+    renderHeader: (options?: {
+        renderPlaceholder?: boolean;
+    }) => string | null | TGenerics['Rendered'];
+    renderFooter: (options?: {
+        renderPlaceholder?: boolean;
+    }) => string | null | TGenerics['Rendered'];
+};
+export declare type HeadersInstance<TGenerics extends TableGenerics> = {
+    getHeaderGroups: () => HeaderGroup<TGenerics>[];
+    getLeftHeaderGroups: () => HeaderGroup<TGenerics>[];
+    getCenterHeaderGroups: () => HeaderGroup<TGenerics>[];
+    getRightHeaderGroups: () => HeaderGroup<TGenerics>[];
+    getFooterGroups: () => HeaderGroup<TGenerics>[];
+    getLeftFooterGroups: () => HeaderGroup<TGenerics>[];
+    getCenterFooterGroups: () => HeaderGroup<TGenerics>[];
+    getRightFooterGroups: () => HeaderGroup<TGenerics>[];
+    getFlatHeaders: () => Header<TGenerics>[];
+    getLeftFlatHeaders: () => Header<TGenerics>[];
+    getCenterFlatHeaders: () => Header<TGenerics>[];
+    getRightFlatHeaders: () => Header<TGenerics>[];
+    getLeafHeaders: () => Header<TGenerics>[];
+    getLeftLeafHeaders: () => Header<TGenerics>[];
+    getCenterLeafHeaders: () => Header<TGenerics>[];
+    getRightLeafHeaders: () => Header<TGenerics>[];
+};
+export declare const Headers: TableFeature;
+export declare function buildHeaderGroups<TGenerics extends TableGenerics>(allColumns: Column<TGenerics>[], columnsToGroup: Column<TGenerics>[], instance: TableInstance<TGenerics>, headerFamily?: 'center' | 'left' | 'right'): HeaderGroup<TGenerics>[];

package/build/types/core/instance.d.ts

@@ -0,0 +1,58 @@
+import { RequiredKeys } from '../utils';
+import { Updater, TableOptionsResolved, TableState, TableInstance, Renderable, TableGenerics, InitialTableState, Row, Column, RowModel, ColumnDef, TableOptions } from '../types';
+export declare type TableFeature = {
+    getDefaultOptions?: (instance: any) => any;
+    getInitialState?: (initialState?: InitialTableState) => any;
+    createInstance?: (instance: any) => any;
+    getDefaultColumnDef?: () => any;
+    createColumn?: (column: any, instance: any) => any;
+    createHeader?: (column: any, instance: any) => any;
+    createCell?: (cell: any, column: any, row: any, instance: any) => any;
+    createRow?: (row: any, instance: any) => any;
+};
+export declare type CoreTableState = {};
+export declare type CoreOptions<TGenerics extends TableGenerics> = {
+    data: TGenerics['Row'][];
+    state: Partial<TableState>;
+    onStateChange: (updater: Updater<TableState>) => void;
+    render: TGenerics['Renderer'];
+    debugAll?: boolean;
+    debugTable?: boolean;
+    debugHeaders?: boolean;
+    debugColumns?: boolean;
+    debugRows?: boolean;
+    initialState?: InitialTableState;
+    autoResetAll?: boolean;
+    mergeOptions?: (defaultOptions: TableOptions<TGenerics>, options: Partial<TableOptions<TGenerics>>) => TableOptions<TGenerics>;
+    meta?: TGenerics['TableMeta'];
+    getCoreRowModel: (instance: TableInstance<any>) => () => RowModel<any>;
+    getSubRows?: (originalRow: TGenerics['Row'], index: number) => undefined | TGenerics['Row'][];
+    getRowId?: (originalRow: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
+    columns: ColumnDef<TGenerics>[];
+    defaultColumn?: Partial<ColumnDef<TGenerics>>;
+    renderFallbackValue: any;
+};
+export declare type CoreInstance<TGenerics extends TableGenerics> = {
+    initialState: TableState;
+    reset: () => void;
+    options: RequiredKeys<TableOptionsResolved<TGenerics>, 'state'>;
+    setOptions: (newOptions: Updater<TableOptionsResolved<TGenerics>>) => void;
+    getState: () => TableState;
+    setState: (updater: Updater<TableState>) => void;
+    _features: readonly TableFeature[];
+    _queue: (cb: () => void) => void;
+    _render: <TProps>(template: Renderable<TGenerics, TProps>, props: TProps) => string | null | TGenerics['Rendered'];
+    _getRowId: (_: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
+    getCoreRowModel: () => RowModel<TGenerics>;
+    _getCoreRowModel?: () => RowModel<TGenerics>;
+    getRowModel: () => RowModel<TGenerics>;
+    getRow: (id: string) => Row<TGenerics>;
+    _getDefaultColumnDef: () => Partial<ColumnDef<TGenerics>>;
+    _getColumnDefs: () => ColumnDef<TGenerics>[];
+    _getAllFlatColumnsById: () => Record<string, Column<TGenerics>>;
+    getAllColumns: () => Column<TGenerics>[];
+    getAllFlatColumns: () => Column<TGenerics>[];
+    getAllLeafColumns: () => Column<TGenerics>[];
+    getColumn: (columnId: string) => Column<TGenerics>;
+};
+export declare function createTableInstance<TGenerics extends TableGenerics>(options: TableOptionsResolved<TGenerics>): TableInstance<TGenerics>;

package/build/types/core/row.d.ts

@@ -0,0 +1,15 @@
+import { Cell, Row, TableGenerics, TableInstance } from '../types';
+export declare type CoreRow<TGenerics extends TableGenerics> = {
+    id: string;
+    index: number;
+    original?: TGenerics['Row'];
+    depth: number;
+    _valuesCache: Record<string, any>;
+    getValue: (columnId: string) => any;
+    subRows: Row<TGenerics>[];
+    getLeafRows: () => Row<TGenerics>[];
+    originalSubRows?: TGenerics['Row'][];
+    getAllCells: () => Cell<TGenerics>[];
+    _getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>;
+};
+export declare const createRow: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, id: string, original: TGenerics["Row"] | undefined, rowIndex: number, depth: number, subRows?: Row<TGenerics>[] | undefined) => Row<TGenerics>;

package/build/types/createTable.d.ts

@@ -0,0 +1,63 @@
+import { CustomFilterFns, FilterFn } from './features/Filters';
+import { AggregationFn, CustomAggregationFns } from './features/Grouping';
+import { CustomSortingFns, SortingFn } from './features/Sorting';
+import { ColumnDef, AccessorFn, AnyRender, TableGenerics, TableOptionsResolved, TableOptions } from './types';
+import { IfDefined, Overwrite } from './utils';
+export declare type TableFactory<TGenerics extends TableGenerics> = () => Table<TGenerics>;
+export declare type CreateTableOptions<TRender extends AnyRender, TFilterFns extends CustomFilterFns<any>, TSortingFns extends CustomSortingFns<any>, TAggregationFns extends CustomAggregationFns<any>, TGenerics extends TableGenerics> = Partial<{
+    render?: TRender;
+    filterFns?: TFilterFns;
+    sortingFns?: TSortingFns;
+    aggregationFns?: TAggregationFns;
+} & Omit<TableOptionsResolved<TGenerics>, 'filterFns' | 'sortingFns' | 'aggregationFns'>>;
+export declare type Table<TGenerics extends TableGenerics> = {
+    generics: TGenerics;
+    options: Partial<TableOptionsResolved<TGenerics>>;
+    setRowType: <TRow>() => Table<Overwrite<TGenerics, {
+        Row: TRow;
+    }>>;
+    setTableMetaType: <TTableMeta>() => Table<Overwrite<TGenerics, {
+        TableMeta: TTableMeta;
+    }>>;
+    setColumnMetaType: <TColumnMeta>() => Table<Overwrite<TGenerics, {
+        ColumnMeta: TColumnMeta;
+    }>>;
+    setFilterMetaType: <TFilterMeta>() => Table<Overwrite<TGenerics, {
+        FilterMeta: TFilterMeta;
+    }>>;
+    setOptions: <TFilterFns extends Record<string, FilterFn<any>>, TSortingFns extends Record<string, SortingFn<any>>, TAggregationFns extends Record<string, AggregationFn<any>>>(options: CreateTableOptions<any, TFilterFns, TSortingFns, TAggregationFns, TGenerics>) => Table<Overwrite<TGenerics, {
+        FilterFns: IfDefined<TFilterFns, TGenerics['FilterFns']>;
+        SortingFns: IfDefined<TSortingFns, TGenerics['SortingFns']>;
+        AggregationFns: IfDefined<TAggregationFns, TGenerics['AggregationFns']>;
+    }>>;
+    createGroup: (column: Overwrite<Overwrite<ColumnDef<any>, {
+        header: string;
+        id?: string;
+    }> | Overwrite<ColumnDef<any>, {
+        id: string;
+        header?: string | ((...any: any) => any);
+    }>, {
+        accessorFn?: never;
+        accessorKey?: never;
+        columns?: ColumnDef<any>[];
+    }>) => ColumnDef<TGenerics>;
+    createDisplayColumn: (column: Omit<ColumnDef<TGenerics>, 'columns'>) => ColumnDef<TGenerics>;
+    createDataColumn: <TAccessor extends AccessorFn<TGenerics['Row']> | keyof TGenerics['Row']>(accessor: TAccessor, column: Overwrite<TAccessor extends (...args: any[]) => any ? ColumnDef<Overwrite<TGenerics, {
+        Value: ReturnType<TAccessor>;
+    }>> : TAccessor extends keyof TGenerics['Row'] ? Overwrite<ColumnDef<Overwrite<TGenerics, {
+        Value: TGenerics['Row'][TAccessor];
+    }>>, {
+        id?: string;
+    }> : never, {
+        accessorFn?: never;
+        accessorKey?: never;
+        columns?: ColumnDef<any>[];
+    }>) => ColumnDef<TGenerics>;
+    createOptions: (options: TableOptions<TGenerics>) => TableOptions<TGenerics>;
+};
+export declare function createTableFactory<TRenderer extends AnyRender>(opts: {
+    render: TRenderer;
+}): () => Table<{
+    Renderer: TRenderer;
+    Rendered: ReturnType<TRenderer>;
+}>;

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

@@ -0,0 +1,63 @@
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, TableGenerics, Updater } from '../types';
+import { ColumnPinningPosition } from './Pinning';
+export declare type ColumnSizingTableState = {
+    columnSizing: ColumnSizingState;
+    columnSizingInfo: ColumnSizingInfoState;
+};
+export declare type ColumnSizingState = Record<string, number>;
+export declare type ColumnSizingInfoState = {
+    startOffset: null | number;
+    startSize: null | number;
+    deltaOffset: null | number;
+    deltaPercentage: null | number;
+    isResizingColumn: false | string;
+    columnSizingStart: [string, number][];
+};
+export declare type ColumnResizeMode = 'onChange' | 'onEnd';
+export declare type ColumnSizingOptions = {
+    enableColumnResizing?: boolean;
+    columnResizeMode?: ColumnResizeMode;
+    onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
+    onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>;
+};
+export declare type ColumnSizingDefaultOptions = {
+    columnResizeMode: ColumnResizeMode;
+    onColumnSizingChange: OnChangeFn<ColumnSizingState>;
+    onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
+};
+export declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
+    setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
+    setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
+    resetColumnSizing: (defaultState?: boolean) => void;
+    resetHeaderSizeInfo: (defaultState?: boolean) => void;
+    getTotalSize: () => number;
+    getLeftTotalSize: () => number;
+    getCenterTotalSize: () => number;
+    getRightTotalSize: () => number;
+};
+export declare type ColumnSizingColumnDef = {
+    enableResizing?: boolean;
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
+};
+export declare type ColumnSizingColumn<TGenerics extends TableGenerics> = {
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
+    getCanResize: () => boolean;
+    getIsResizing: () => boolean;
+    resetSize: () => void;
+};
+export declare type ColumnSizingHeader<TGenerics extends TableGenerics> = {
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
+    getResizeHandler: () => (event: unknown) => void;
+};
+export declare const defaultColumnSizing: {
+    size: number;
+    minSize: number;
+    maxSize: number;
+};
+export declare const ColumnSizing: TableFeature;
+export declare function passiveEventSupported(): boolean;

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

@@ -0,0 +1,39 @@
+import { RowModel } from '..';
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
+export declare type ExpandedStateList = Record<string, boolean>;
+export declare type ExpandedState = true | Record<string, boolean>;
+export declare type ExpandedTableState = {
+    expanded: ExpandedState;
+};
+export declare type ExpandedRow = {
+    toggleExpanded: (expanded?: boolean) => void;
+    getIsExpanded: () => boolean;
+    getCanExpand: () => boolean;
+    getToggleExpandedHandler: () => () => void;
+};
+export declare type ExpandedOptions<TGenerics extends TableGenerics> = {
+    manualExpanding?: boolean;
+    onExpandedChange?: OnChangeFn<ExpandedState>;
+    autoResetExpanded?: boolean;
+    enableExpanding?: boolean;
+    getExpandedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    getIsRowExpanded?: (row: Row<TGenerics>) => boolean;
+    getRowCanExpand?: (row: Row<TGenerics>) => boolean;
+    paginateExpandedRows?: boolean;
+};
+export declare type ExpandedInstance<TGenerics extends TableGenerics> = {
+    _autoResetExpanded: () => void;
+    setExpanded: (updater: Updater<ExpandedState>) => void;
+    toggleAllRowsExpanded: (expanded?: boolean) => void;
+    resetExpanded: (defaultState?: boolean) => void;
+    getCanSomeRowsExpand: () => boolean;
+    getToggleAllRowsExpandedHandler: () => (event: unknown) => void;
+    getIsSomeRowsExpanded: () => boolean;
+    getIsAllRowsExpanded: () => boolean;
+    getExpandedDepth: () => number;
+    getExpandedRowModel: () => RowModel<TGenerics>;
+    _getExpandedRowModel?: () => RowModel<TGenerics>;
+    getPreExpandedRowModel: () => RowModel<TGenerics>;
+};
+export declare const Expanding: TableFeature;

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

@@ -0,0 +1,90 @@
+import { RowModel } from '..';
+import { TableFeature } from '../core/instance';
+import { BuiltInFilterFn } from '../filterFns';
+import { Column, OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
+import { Overwrite } from '../utils';
+export declare type FiltersTableState = {
+    columnFilters: ColumnFiltersState;
+    globalFilter: any;
+};
+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> = {
+    (row: Row<TGenerics>, columnId: string, filterValue: any, addMeta: (meta: TGenerics['FilterMeta']) => void): boolean;
+    resolveFilterValue?: TransformFilterValueFn<TGenerics>;
+    autoRemove?: ColumnFilterAutoRemoveTestFn<TGenerics>;
+};
+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> = {
+    filterFn?: FilterFnOption<Overwrite<TGenerics, {
+        Value: any;
+    }>>;
+    enableColumnFilter?: boolean;
+    enableGlobalFilter?: boolean;
+};
+export declare type FiltersColumn<TGenerics extends TableGenerics> = {
+    getAutoFilterFn: () => FilterFn<TGenerics> | undefined;
+    getFilterFn: () => FilterFn<TGenerics> | undefined;
+    setFilterValue: (updater: Updater<any>) => void;
+    getCanFilter: () => boolean;
+    getCanGlobalFilter: () => boolean;
+    getFacetedRowModel: () => RowModel<TGenerics>;
+    _getFacetedRowModel?: () => RowModel<TGenerics>;
+    getIsFiltered: () => boolean;
+    getFilterValue: () => unknown;
+    getFilterIndex: () => number;
+    getFacetedUniqueValues: () => Map<any, number>;
+    _getFacetedUniqueValues?: () => Map<any, number>;
+    getFacetedMinMaxValues: () => undefined | [number, number];
+    _getFacetedMinMaxValues?: () => undefined | [number, number];
+};
+export declare type FiltersRow<TGenerics extends TableGenerics> = {
+    columnFilters: Record<string, boolean>;
+    columnFiltersMeta: Record<string, TGenerics['FilterMeta']>;
+};
+export declare type FiltersOptions<TGenerics extends TableGenerics> = {
+    enableFilters?: boolean;
+    manualFiltering?: boolean;
+    filterFromLeafRows?: boolean;
+    filterFns?: TGenerics['FilterFns'];
+    getFilteredRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
+    enableColumnFilters?: boolean;
+    globalFilterFn?: FilterFnOption<TGenerics>;
+    onGlobalFilterChange?: OnChangeFn<any>;
+    enableGlobalFilter?: boolean;
+    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) => () => undefined | [number, number];
+};
+export declare type FiltersInstance<TGenerics extends TableGenerics> = {
+    setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
+    resetColumnFilters: (defaultState?: boolean) => void;
+    getPreFilteredRowModel: () => RowModel<TGenerics>;
+    getFilteredRowModel: () => RowModel<TGenerics>;
+    _getFilteredRowModel?: () => RowModel<TGenerics>;
+    setGlobalFilter: (updater: Updater<any>) => void;
+    resetGlobalFilter: (defaultState?: boolean) => void;
+    getGlobalAutoFilterFn: () => FilterFn<TGenerics> | undefined;
+    getGlobalFilterFn: () => FilterFn<TGenerics> | undefined;
+    getGlobalFacetedRowModel: () => RowModel<TGenerics>;
+    _getGlobalFacetedRowModel?: () => RowModel<TGenerics>;
+    getGlobalFacetedUniqueValues: () => Map<any, number>;
+    _getGlobalFacetedUniqueValues?: () => Map<any, number>;
+    getGlobalFacetedMinMaxValues: () => undefined | [number, number];
+    _getGlobalFacetedMinMaxValues?: () => undefined | [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

@@ -0,0 +1,68 @@
+import { RowModel } from '..';
+import { BuiltInAggregationFn } from '../aggregationFns';
+import { TableFeature } from '../core/instance';
+import { Cell, Column, OnChangeFn, TableInstance, Row, Updater, Renderable, TableGenerics } from '../types';
+import { Overwrite } from '../utils';
+export declare type GroupingState = string[];
+export declare type GroupingTableState = {
+    grouping: GroupingState;
+};
+export declare type AggregationFn<TGenerics extends TableGenerics> = (columnId: string, leafRows: Row<TGenerics>[], childRows: Row<TGenerics>[]) => any;
+export declare type CustomAggregationFns<TGenerics extends TableGenerics> = Record<string, AggregationFn<TGenerics>>;
+export declare type AggregationFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInAggregationFn | keyof TGenerics['AggregationFns'] | AggregationFn<TGenerics>;
+export declare type GroupingColumnDef<TGenerics extends TableGenerics> = {
+    aggregationFn?: AggregationFnOption<Overwrite<TGenerics, {
+        Value: any;
+    }>>;
+    aggregatedCell?: Renderable<TGenerics, {
+        instance: TableInstance<TGenerics>;
+        row: Row<TGenerics>;
+        column: Column<TGenerics>;
+        cell: Cell<TGenerics>;
+        getValue: () => TGenerics['Value'];
+    }>;
+    enableGrouping?: boolean;
+};
+export declare type GroupingColumn<TGenerics extends TableGenerics> = {
+    getCanGroup: () => boolean;
+    getIsGrouped: () => boolean;
+    getGroupedIndex: () => number;
+    toggleGrouping: () => void;
+    getToggleGroupingHandler: () => () => void;
+    getAutoAggregationFn: () => AggregationFn<TGenerics> | undefined;
+    getAggregationFn: () => 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;
+    getIsPlaceholder: () => boolean;
+    getIsAggregated: () => boolean;
+    renderAggregatedCell: () => string | null | TGenerics['Rendered'];
+};
+export declare type ColumnDefaultOptions = {
+    onGroupingChange: OnChangeFn<GroupingState>;
+    enableGrouping: boolean;
+};
+export declare type GroupingOptions<TGenerics extends TableGenerics> = {
+    manualGrouping?: boolean;
+    aggregationFns?: TGenerics['AggregationFns'];
+    onGroupingChange?: OnChangeFn<GroupingState>;
+    enableGrouping?: boolean;
+    getGroupedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    groupedColumnMode?: false | 'reorder' | 'remove';
+};
+export declare type GroupingColumnMode = false | 'reorder' | 'remove';
+export declare type GroupingInstance<TGenerics extends TableGenerics> = {
+    setGrouping: (updater: Updater<GroupingState>) => void;
+    resetGrouping: (defaultState?: boolean) => void;
+    getPreGroupedRowModel: () => RowModel<TGenerics>;
+    getGroupedRowModel: () => RowModel<TGenerics>;
+    _getGroupedRowModel?: () => RowModel<TGenerics>;
+};
+export declare const Grouping: TableFeature;
+export declare function orderColumns<TGenerics extends TableGenerics>(leafColumns: Column<TGenerics>[], grouping: string[], groupedColumnMode?: GroupingColumnMode): Column<TGenerics>[];

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

@@ -0,0 +1,18 @@
+import { OnChangeFn, Updater, Column, TableGenerics } from '../types';
+import { TableFeature } from '../core/instance';
+export declare type ColumnOrderTableState = {
+    columnOrder: ColumnOrderState;
+};
+export declare type ColumnOrderState = string[];
+export declare type ColumnOrderOptions = {
+    onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
+};
+export declare type ColumnOrderDefaultOptions = {
+    onColumnOrderChange: OnChangeFn<ColumnOrderState>;
+};
+export declare type ColumnOrderInstance<TGenerics extends TableGenerics> = {
+    setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
+    resetColumnOrder: (defaultState?: boolean) => void;
+    _getOrderColumnsFn: () => (columns: Column<TGenerics>[]) => Column<TGenerics>[];
+};
+export declare const Ordering: TableFeature;

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

@@ -0,0 +1,42 @@
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, TableGenerics, TableInstance, RowModel, Updater } from '../types';
+export declare type PaginationState = {
+    pageIndex: number;
+    pageSize: number;
+};
+export declare type PaginationTableState = {
+    pagination: PaginationState;
+};
+export declare type PaginationInitialTableState = {
+    pagination?: Partial<PaginationState>;
+};
+export declare type PaginationOptions<TGenerics extends TableGenerics> = {
+    pageCount?: number;
+    manualPagination?: boolean;
+    onPaginationChange?: OnChangeFn<PaginationState>;
+    autoResetPageIndex?: boolean;
+    getPaginationRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+};
+export declare type PaginationDefaultOptions = {
+    onPaginationChange: OnChangeFn<PaginationState>;
+};
+export declare type PaginationInstance<TGenerics extends TableGenerics> = {
+    _autoResetPageIndex: () => void;
+    setPagination: (updater: Updater<PaginationState>) => void;
+    resetPagination: (defaultState?: boolean) => void;
+    setPageIndex: (updater: Updater<number>) => void;
+    resetPageIndex: (defaultState?: boolean) => void;
+    setPageSize: (updater: Updater<number>) => void;
+    resetPageSize: (defaultState?: boolean) => void;
+    setPageCount: (updater: Updater<number>) => void;
+    getPageOptions: () => number[];
+    getCanPreviousPage: () => boolean;
+    getCanNextPage: () => boolean;
+    previousPage: () => void;
+    nextPage: () => void;
+    getPrePaginationRowModel: () => RowModel<TGenerics>;
+    getPaginationRowModel: () => RowModel<TGenerics>;
+    _getPaginationRowModel?: () => RowModel<TGenerics>;
+    getPageCount: () => number;
+};
+export declare const Pagination: TableFeature;

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

@@ -0,0 +1,40 @@
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, Updater, Column, TableGenerics, Cell } from '../types';
+export declare type ColumnPinningPosition = false | 'left' | 'right';
+export declare type ColumnPinningState = {
+    left?: string[];
+    right?: string[];
+};
+export declare type ColumnPinningTableState = {
+    columnPinning: ColumnPinningState;
+};
+export declare type ColumnPinningOptions = {
+    onColumnPinningChange?: OnChangeFn<ColumnPinningState>;
+    enablePinning?: boolean;
+};
+export declare type ColumnPinningDefaultOptions = {
+    onColumnPinningChange: OnChangeFn<ColumnPinningState>;
+};
+export declare type ColumnPinningColumnDef = {
+    enablePinning?: boolean;
+};
+export declare type ColumnPinningColumn = {
+    getCanPin: () => boolean;
+    getPinnedIndex: () => number;
+    getIsPinned: () => ColumnPinningPosition;
+    pin: (position: ColumnPinningPosition) => void;
+};
+export declare type ColumnPinningRow<TGenerics extends TableGenerics> = {
+    getLeftVisibleCells: () => Cell<TGenerics>[];
+    getCenterVisibleCells: () => Cell<TGenerics>[];
+    getRightVisibleCells: () => Cell<TGenerics>[];
+};
+export declare type ColumnPinningInstance<TGenerics extends TableGenerics> = {
+    setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
+    resetColumnPinning: (defaultState?: boolean) => void;
+    getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean;
+    getLeftLeafColumns: () => Column<TGenerics>[];
+    getRightLeafColumns: () => Column<TGenerics>[];
+    getCenterLeafColumns: () => Column<TGenerics>[];
+};
+export declare const Pinning: TableFeature;

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

@@ -0,0 +1,40 @@
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, TableGenerics, TableInstance, Row, RowModel, Updater } from '../types';
+export declare type RowSelectionState = Record<string, boolean>;
+export declare type RowSelectionTableState = {
+    rowSelection: RowSelectionState;
+};
+export declare type RowSelectionOptions<TGenerics extends TableGenerics> = {
+    enableRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
+    enableMultiRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
+    enableSubRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
+    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
+};
+export declare type RowSelectionRow = {
+    getIsSelected: () => boolean;
+    getIsSomeSelected: () => boolean;
+    getCanSelect: () => boolean;
+    getCanMultiSelect: () => boolean;
+    getCanSelectSubRows: () => boolean;
+    toggleSelected: (value?: boolean) => void;
+    getToggleSelectedHandler: () => (event: unknown) => void;
+};
+export declare type RowSelectionInstance<TGenerics extends TableGenerics> = {
+    getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
+    getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
+    setRowSelection: (updater: Updater<RowSelectionState>) => void;
+    resetRowSelection: (defaultState?: boolean) => void;
+    getIsAllRowsSelected: () => boolean;
+    getIsAllPageRowsSelected: () => boolean;
+    getIsSomeRowsSelected: () => boolean;
+    getIsSomePageRowsSelected: () => boolean;
+    toggleAllRowsSelected: (value?: boolean) => void;
+    toggleAllPageRowsSelected: (value?: boolean) => void;
+    getPreSelectedRowModel: () => RowModel<TGenerics>;
+    getSelectedRowModel: () => RowModel<TGenerics>;
+    getFilteredSelectedRowModel: () => RowModel<TGenerics>;
+    getGroupedSelectedRowModel: () => RowModel<TGenerics>;
+};
+export declare const RowSelection: TableFeature;
+export declare function selectRowsFn<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>): RowModel<TGenerics>;
+export declare function isRowSelected<TGenerics extends TableGenerics>(row: Row<TGenerics>, selection: Record<string, boolean>, instance: TableInstance<TGenerics>): boolean | 'some';