@tanstack/table-core 8.0.11 → 8.0.12

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

@@ -0,0 +1,63 @@
+import { RowModel } from '..';
+import { TableFeature } from '../core/instance';
+import { BuiltInSortingFn } from '../sortingFns';
+import { OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
+import { Overwrite } from '../utils';
+export declare type SortDirection = 'asc' | 'desc';
+export declare type ColumnSort = {
+    id: string;
+    desc: boolean;
+};
+export declare type SortingState = ColumnSort[];
+export declare type SortingTableState = {
+    sorting: SortingState;
+};
+export declare type SortingFn<TGenerics extends TableGenerics> = {
+    (rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number;
+};
+export declare type CustomSortingFns<TGenerics extends TableGenerics> = Record<string, SortingFn<TGenerics>>;
+export declare type SortingFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInSortingFn | keyof TGenerics['SortingFns'] | SortingFn<TGenerics>;
+export declare type SortingColumnDef<TGenerics extends TableGenerics> = {
+    sortingFn?: SortingFnOption<Overwrite<TGenerics, {
+        Value: any;
+    }>>;
+    sortDescFirst?: boolean;
+    enableSorting?: boolean;
+    enableMultiSort?: boolean;
+    invertSorting?: boolean;
+    sortUndefined?: false | -1 | 1;
+};
+export declare type SortingColumn<TGenerics extends TableGenerics> = {
+    getAutoSortingFn: () => SortingFn<TGenerics>;
+    getAutoSortDir: () => SortDirection;
+    getSortingFn: () => SortingFn<TGenerics>;
+    getNextSortingOrder: () => SortDirection | false;
+    getCanSort: () => boolean;
+    getCanMultiSort: () => boolean;
+    getSortIndex: () => number;
+    getIsSorted: () => false | SortDirection;
+    clearSorting: () => void;
+    toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
+    getToggleSortingHandler: () => undefined | ((event: unknown) => void);
+};
+export declare type SortingOptions<TGenerics extends TableGenerics> = {
+    manualSorting?: boolean;
+    sortingFns?: TGenerics['SortingFns'];
+    onSortingChange?: OnChangeFn<SortingState>;
+    enableSorting?: boolean;
+    enableSortingRemoval?: boolean;
+    enableMultiRemove?: boolean;
+    enableMultiSort?: boolean;
+    sortDescFirst?: boolean;
+    getSortedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    maxMultiSortColCount?: number;
+    isMultiSortEvent?: (e: unknown) => boolean;
+};
+export declare type SortingInstance<TGenerics extends TableGenerics> = {
+    setSorting: (updater: Updater<SortingState>) => void;
+    resetSorting: (defaultState?: boolean) => void;
+    getPreSortedRowModel: () => RowModel<TGenerics>;
+    getSortedRowModel: () => RowModel<TGenerics>;
+    _getSortedRowModel?: () => RowModel<TGenerics>;
+};
+export declare const Sorting: TableFeature;

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

@@ -0,0 +1,40 @@
+import { TableFeature } from '../core/instance';
+import { Cell, Column, OnChangeFn, TableGenerics, Updater } from '../types';
+export declare type VisibilityState = Record<string, boolean>;
+export declare type VisibilityTableState = {
+    columnVisibility: VisibilityState;
+};
+export declare type VisibilityOptions = {
+    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
+    enableHiding?: boolean;
+};
+export declare type VisibilityDefaultOptions = {
+    onColumnVisibilityChange: OnChangeFn<VisibilityState>;
+};
+export declare type VisibilityInstance<TGenerics extends TableGenerics> = {
+    getVisibleFlatColumns: () => Column<TGenerics>[];
+    getVisibleLeafColumns: () => Column<TGenerics>[];
+    getLeftVisibleLeafColumns: () => Column<TGenerics>[];
+    getRightVisibleLeafColumns: () => Column<TGenerics>[];
+    getCenterVisibleLeafColumns: () => Column<TGenerics>[];
+    setColumnVisibility: (updater: Updater<VisibilityState>) => void;
+    resetColumnVisibility: (defaultState?: boolean) => void;
+    toggleAllColumnsVisible: (value?: boolean) => void;
+    getIsAllColumnsVisible: () => boolean;
+    getIsSomeColumnsVisible: () => boolean;
+    getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
+};
+export declare type VisibilityColumnDef = {
+    enableHiding?: boolean;
+};
+export declare type VisibilityRow<TGenerics extends TableGenerics> = {
+    _getAllVisibleCells: () => Cell<TGenerics>[];
+    getVisibleCells: () => Cell<TGenerics>[];
+};
+export declare type VisibilityColumn = {
+    getCanHide: () => boolean;
+    getIsVisible: () => boolean;
+    toggleVisibility: (value?: boolean) => void;
+    getToggleVisibilityHandler: () => (event: unknown) => void;
+};
+export declare const Visibility: TableFeature;

package/build/types/filterFns.d.ts

@@ -0,0 +1,13 @@
+import { FilterFn } from './features/Filters';
+export declare const filterFns: {
+    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;

package/build/types/index.d.ts

@@ -0,0 +1,29 @@
+export * from './core/instance';
+export * from './types';
+export * from './createTable';
+export * from './core/column';
+export * from './core/headers';
+export * from './core/row';
+export * from './features/ColumnSizing';
+export * from './features/Expanding';
+export * from './features/Filters';
+export * from './features/Grouping';
+export * from './features/Ordering';
+export * from './features/Pagination';
+export * from './features/Pinning';
+export * from './features/RowSelection';
+export * from './features/Sorting';
+export * from './features/Visibility';
+export * from './filterFns';
+export * from './sortingFns';
+export * from './aggregationFns';
+export * from './utils';
+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/sortingFns.d.ts

@@ -0,0 +1,11 @@
+import { SortingFn } from './features/Sorting';
+export declare const reSplitAlphaNumeric: RegExp;
+export declare const sortingFns: {
+    alphanumeric: SortingFn<any>;
+    alphanumericCaseSensitive: SortingFn<any>;
+    text: SortingFn<any>;
+    textCaseSensitive: SortingFn<any>;
+    datetime: SortingFn<any>;
+    basic: SortingFn<any>;
+};
+export declare type BuiltInSortingFn = keyof typeof sortingFns;

package/build/types/types.d.ts

@@ -0,0 +1,53 @@
+import { CoreOptions, CoreTableState, CoreInstance } from './core/instance';
+import { CoreColumn, CoreColumnDef } from './core/column';
+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 { CoreHeader, CoreHeaderGroup, HeadersInstance } from './core/headers';
+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';
+import { ColumnSizingColumn, ColumnSizingColumnDef, ColumnSizingHeader, ColumnSizingInstance, ColumnSizingOptions, ColumnSizingTableState } from './features/ColumnSizing';
+import { PaginationInitialTableState, PaginationInstance, PaginationOptions, PaginationTableState } from './features/Pagination';
+import { RowSelectionInstance, RowSelectionOptions, RowSelectionRow, RowSelectionTableState } from './features/RowSelection';
+import { CoreRow } from './core/row';
+import { PartialKeys } from './utils';
+import { CoreCell } from './core/cell';
+export declare type Updater<T> = T | ((old: T) => T);
+export declare type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
+export declare type TableGenerics = {
+    Row?: any;
+    Value?: any;
+    FilterFns?: any;
+    SortingFns?: any;
+    AggregationFns?: any;
+    Renderer?: any;
+    Rendered?: any;
+    ColumnMeta?: any;
+    TableMeta?: any;
+    FilterMeta?: any;
+};
+export declare type AnyRender = (Comp: any, props: any) => any;
+export declare type TableInstance<TGenerics extends TableGenerics> = CoreInstance<TGenerics> & HeadersInstance<TGenerics> & VisibilityInstance<TGenerics> & ColumnOrderInstance<TGenerics> & ColumnPinningInstance<TGenerics> & FiltersInstance<TGenerics> & SortingInstance<TGenerics> & GroupingInstance<TGenerics> & ColumnSizingInstance<TGenerics> & ExpandedInstance<TGenerics> & PaginationInstance<TGenerics> & RowSelectionInstance<TGenerics>;
+export declare type TableOptionsResolved<TGenerics extends TableGenerics> = CoreOptions<TGenerics> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TGenerics> & SortingOptions<TGenerics> & GroupingOptions<TGenerics> & ExpandedOptions<TGenerics> & ColumnSizingOptions & PaginationOptions<TGenerics> & RowSelectionOptions<TGenerics>;
+export declare type TableOptions<TGenerics extends TableGenerics> = Omit<PartialKeys<TableOptionsResolved<TGenerics>, 'state' | 'onStateChange'>, 'render' | 'renderFallbackValue'>;
+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> & VisibilityRow<TGenerics> & ColumnPinningRow<TGenerics> & FiltersRow<TGenerics> & GroupingRow & RowSelectionRow & ExpandedRow;
+export declare type RowValues = {
+    [key: string]: any;
+};
+export declare type RowModel<TGenerics extends TableGenerics> = {
+    rows: Row<TGenerics>[];
+    flatRows: Row<TGenerics>[];
+    rowsById: Record<string, Row<TGenerics>>;
+};
+export declare type AccessorFn<TData> = (originalRow: TData, index: number) => any;
+export declare type Renderable<TGenerics extends TableGenerics, TProps> = string | ((props: TProps) => TGenerics['Rendered']);
+export declare type ColumnDef<TGenerics extends TableGenerics> = CoreColumnDef<TGenerics> & VisibilityColumnDef & ColumnPinningColumnDef & FiltersColumnDef<TGenerics> & SortingColumnDef<TGenerics> & GroupingColumnDef<TGenerics> & ColumnSizingColumnDef;
+export declare type Column<TGenerics extends TableGenerics> = CoreColumn<TGenerics> & ColumnVisibilityColumn & ColumnPinningColumn & FiltersColumn<TGenerics> & SortingColumn<TGenerics> & GroupingColumn<TGenerics> & ColumnSizingColumn<TGenerics>;
+export declare type Cell<TGenerics extends TableGenerics> = CoreCell<TGenerics> & GroupingCell<TGenerics>;
+export declare type Header<TGenerics extends TableGenerics> = CoreHeader<TGenerics> & ColumnSizingHeader<TGenerics>;
+export declare type HeaderGroup<TGenerics extends TableGenerics> = CoreHeaderGroup<TGenerics>;
+export declare type NoInfer<A extends any> = [A][A extends any ? 0 : never];

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

@@ -0,0 +1,4 @@
+import { TableGenerics, Row, RowModel, TableInstance } from '../types';
+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/getExpandedRowModel.d.ts

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

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

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

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

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

@@ -0,0 +1,4 @@
+import { TableInstance, RowModel, TableGenerics } from '../types';
+export declare function getPaginationRowModel<TGenerics extends TableGenerics>(opts?: {
+    initialSync: boolean;
+}): (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

@@ -0,0 +1,19 @@
+import { NoInfer, TableState, Updater } from './types';
+export declare type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export declare type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export declare type Overwrite<T, U extends {
+    [TKey in keyof T]?: any;
+}> = Omit<T, keyof U> & U;
+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 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: any;
+    debug?: () => any;
+    onChange?: (result: TResult) => void;
+}): () => TResult;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/table-core",
   "author": "Tanner Linsley",
-  "version": "8.0.11",
+  "version": "8.0.12",
   "description": "Headless UI for building powerful tables & datagrids for TS/JS.",
   "license": "MIT",
   "homepage": "https://github.com/tanstack/table#readme",
@@ -33,7 +33,7 @@
     "node": ">=12"
   },
   "files": [
-    "build",
+    "build/**",
     "src"
   ]
 }