@economic/taco 2.18.0 → 2.20.0

package/dist/index.css

@@ -895,17 +895,17 @@
     @apply !my-0;
 }
 
-/* When cell is editable, but not highlighted, then we apply cell padding to a cell itself */
+/* When cell is editable, but not highlighted, then we apply cell padding to a cell itself and remove 1px border-width */
 
 [data-font-size='small'] [role='cell'][data-editable]:not([data-highlighted='true']) {
-        @apply px-[calc(var(--table3-cell-padding-x)_-_6px)];
+        @apply px-[calc(var(--table3-cell-padding-x)_-_6px_-_1px)];
     }
 
-/* When cell is editable and highlighted, the padding should apply to highlight wrapper, 
+/* When cell is editable and highlighted, the padding should apply to highlight wrapper and remove 1px border-width,
        because it should take all the available space in the cell */
 
 [data-font-size='small'] [role='cell'][data-editable][data-highlighted='true'] [data-taco='highlight'] {
-        @apply px-[calc(var(--table3-cell-padding-x)_-_6px)];
+        @apply px-[calc(var(--table3-cell-padding-x)_-_6px_-_1px)];
     }
 
 [data-font-size='small'] [role='cell'][data-editable] [data-taco='checkbox'],
@@ -934,17 +934,17 @@
     @apply !-my-[5px];
 }
 
-/* When cell is editable, but not highlighted, then we apply cell padding to a cell itself */
+/* When cell is editable, but not highlighted, then we apply cell padding to a cell itself and remove 1px border-width */
 
 [data-font-size='medium'] [role='cell'][data-editable]:not([data-highlighted='true']) {
-        @apply px-[calc(var(--table3-cell-padding-x)_-_8px)];
+        @apply px-[calc(var(--table3-cell-padding-x)_-_8px_-_1px)];
     }
 
-/* When cell is editable and highlighted, the padding should apply to highlight wrapper, 
+/* When cell is editable and highlighted, the padding should apply to highlight wrapper and remove 1px border-width, 
        because it should take all the available space in the cell */
 
 [data-font-size='medium'] [role='cell'][data-editable][data-highlighted='true'] [data-taco='highlight'] {
-        @apply px-[calc(var(--table3-cell-padding-x)_-_8px)];
+        @apply px-[calc(var(--table3-cell-padding-x)_-_8px_-_1px)];
     }
 
 [data-font-size='medium'] [role='cell'][data-editable] [data-taco='checkbox'],
@@ -1003,17 +1003,17 @@
     @apply !h-6 !w-6;
 }
 
-/* When cell is editable, but not highlighted, then we apply cell padding to a cell itself */
+/* When cell is editable, but not highlighted, then we apply cell padding to a cell itself and remove 1px border-width */
 
 [data-font-size='large'] [role='cell'][data-editable]:not([data-highlighted='true']) {
-        @apply px-[calc(var(--table3-cell-padding-x)_-_10px)];
+        @apply px-[calc(var(--table3-cell-padding-x)_-_10px_-_1px)];
     }
 
-/* When cell is editable and highlighted, the padding should apply to highlight wrapper, 
+/* When cell is editable and highlighted, the padding should apply to highlight wrapper and remove 1px border-width, 
        because it should take all the available space in the cell */
 
 [data-font-size='large'] [role='cell'][data-editable][data-highlighted='true'] [data-taco='highlight'] {
-        @apply px-[calc(var(--table3-cell-padding-x)_-_10px)];
+        @apply px-[calc(var(--table3-cell-padding-x)_-_10px_-_1px)];
     }
 
 [data-font-size='large'] [role='cell'][data-editable] [data-taco='checkbox'],

package/dist/primitives/Table/types.d.ts

@@ -1,5 +1,9 @@
-import { ColumnFilter as ReactTableColumnFilter, ColumnSort as ReactTableColumnSort } from '@tanstack/react-table';
-export declare type TableRef = HTMLDivElement & {
+/// <reference types="react" />
+import { ColumnFilter as ReactTableColumnFilter, ColumnFiltersState as ReactTableColumnFilterState, ColumnOrderState as ReactTableColumnOrderState, ColumnPinningState as ReactTableColumnPinningState, ColumnSort as ReactTableColumnSort, ColumnSizingState as ReactTableColumnSizingState, GroupingState as ReactTableGroupingState, VisibilityState as ReactTableColumnVisibilityState, SortingState as ReactTableSortingState, BuiltInAggregationFn as ReactTableBuiltInAggregationFn, BuiltInSortingFn as ReactTableBuiltInSortingFn, HeaderContext as ReactTableHeaderContext, CellContext as ReactTableCellContext, ColumnMeta as ReactTableColumnMeta } from '@tanstack/react-table';
+import { FontSizes, ValueOf } from '../../types';
+import { MenuProps } from '../../components/Menu/Menu';
+declare type TODO = any;
+export declare type TableRef = HTMLTableElement & {
     instance: {
         resetFiltering: () => void;
         resetRowExpansion: () => void;
@@ -7,14 +11,57 @@ export declare type TableRef = HTMLDivElement & {
         resetSorting: () => void;
     };
 };
-export declare enum TableFontSizes {
-    small = "small",
-    medium = "medium",
-    large = "large"
+export declare enum TableFilterComparator {
+    Contains = 0,
+    DoesNotContain = 1,
+    IsEqualTo = 2,
+    IsNotEqualTo = 3,
+    IsGreaterThan = 4,
+    IsLessThan = 5,
+    IsBetween = 6,
+    IsEmpty = 7,
+    IsNotEmpty = 8,
+    IsLessThanOrEqualTo = 9,
+    IsGreaterThanOrEqualTo = 10,
+    HasAnyOf = 11,
+    HasAllOf = 12,
+    HasNoneOf = 13
 }
-export declare type TableFontSize = keyof typeof TableFontSizes;
+export declare type TableFilterValue = {
+    comparator: TableFilterComparator;
+    value: any;
+};
+export declare type TableFilter = {
+    id: string;
+    value: TableFilterValue;
+};
+export declare type TableColumnAlignment = 'left' | 'center' | 'right';
+export declare type TableColumnClassNameHandler<TType = unknown> = string | ((row: TType) => string | undefined);
+export declare type TableColumnDataType = 'auto' | 'number' | 'alphanumeric' | 'alphanumericCaseSensitive' | 'datetime' | 'boolean';
 export declare type TableColumnFilter = ReactTableColumnFilter;
+export declare type TableColumnMenu = (props: Partial<MenuProps>) => JSX.Element;
+export declare type TableColumnRenderer<TType, TValue> = (value: TValue, row: TType) => JSX.Element | string | number | null;
+export declare type TableColumnRendererAggregate<TType, TValue> = (value: TValue, row: TType) => JSX.Element | string | number | null;
+export declare type TableColumnRendererControl<TType = unknown> = ((props: TableColumnRendererControlProps, row?: TType) => JSX.Element) | 'datepicker' | 'input' | 'switch' | 'textarea';
+export declare type TableColumnRendererControlProps = {
+    className?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    onBlur?: (value: unknown) => void;
+    onFocus?: React.FocusEventHandler;
+    readOnly?: boolean;
+    ref: React.RefObject<HTMLElement> | ((instance: HTMLElement | null | undefined) => void);
+    setValue: (value: unknown) => void;
+    value: unknown;
+};
+export declare type TableColumnRendererHeader = string;
+export declare type TableColumnRendererFooter<TValue> = (values: TValue[]) => JSX.Element | string | number | null;
 export declare type TableColumnSort = ReactTableColumnSort;
+export declare type TableColumnSortDirection = 'asc' | 'desc';
+export declare type TableColumnSortFn<TType = unknown> = ((rowA: TType, rowB: TType, columnId: string) => -1 | 0 | 1) | ReactTableBuiltInSortingFn | 'auto';
+export declare type TableColumnWidth = number | 'grow';
+export declare type TableRowActionRenderer<TType = unknown> = (row: TType) => JSX.Element | null;
+export declare type TableRowActionGroupRenderer<TType = unknown> = (rows: TType[]) => JSX.Element | null;
 export declare type TableRowClickHandler<TType = unknown> = (row: TType) => void;
 export declare type TableRowGotoHandler = (column: string, query: string, sorting: TableColumnSort[], filters: TableColumnFilter[], search: string | undefined) => Promise<number>;
 export declare type TableRowHeight = 'short' | 'medium' | 'tall' | 'extra-tall';
@@ -26,10 +73,142 @@ export declare type TableShortcutHandlerObject<TType = unknown> = {
     shift?: boolean;
 };
 export declare type TableFilterHandler = (filters: TableColumnFilter[]) => void;
+export declare type TableFontSize = keyof typeof FontSizes;
+export declare type TablePreset = 'lite' | 'complex';
+export declare type TableRowExpansionRenderer<TType = unknown> = (row: TType) => (() => JSX.Element) | null;
 export declare type TableScrollToIndexHandler = (index: number, options?: {
     align: 'start' | 'center' | 'end' | 'auto';
 }) => void;
 export declare type TableServerLoadPageHandler = (pageIndex: number, sorting: TableColumnSort[], filters: TableColumnFilter[], search: string | undefined) => Promise<void>;
 export declare type TableServerLoadAllHandler = (sorting: TableColumnSort[], filters: TableColumnFilter[], search: string | undefined) => Promise<void>;
+export declare enum TableServerLoadAllState {
+    Incomplete = 0,
+    Loading = 1,
+    Completed = 2
+}
+export declare type TableSettingsHandler = (settings: TableSettings) => void | Promise<void>;
 export declare type TableShortcuts<TType = unknown> = Record<string, TableShortcutHandlerFn<TType> | TableShortcutHandlerObject<TType>>;
 export declare type TableSortHandler = (sorting: TableColumnSort[]) => void;
+export declare type TableSettings = {
+    columnFilters?: ReactTableColumnFilterState;
+    columnOrder?: ReactTableColumnOrderState;
+    columnPinning?: ReactTableColumnPinningState;
+    columnSizing?: ReactTableColumnSizingState;
+    columnVisibility?: ReactTableColumnVisibilityState;
+    excludeUnmatchedRecordsInSearch?: boolean;
+    fontSize?: TableFontSize;
+    grouping?: ReactTableGroupingState;
+    rowHeight?: TableRowHeight;
+    showWarningWhenPrintingLargeDataset?: boolean;
+    searchQuery?: string;
+    sorting?: ReactTableSortingState;
+};
+export declare type TableFeatureProps = {
+    enableFiltering?: boolean;
+    enableSearch?: boolean;
+    enableSorting?: boolean;
+    enableColumnFreezing?: boolean;
+    enableColumnHiding?: boolean;
+    enableColumnResizing?: boolean;
+    enableRowExpansion?: boolean;
+    enableRowSelection?: boolean;
+    enableRowSelectionSingle?: boolean;
+    enableColumnOrdering?: boolean;
+    enableFontSize?: boolean;
+    enableFooter?: boolean;
+    enablePrinting?: boolean;
+    enableRowActions?: boolean;
+    enableRowActive?: boolean;
+    enableRowClick?: boolean;
+    enableRowGoto?: boolean;
+    enableRowHeight?: boolean;
+    enableSettings?: boolean;
+};
+export declare type useTableInternalColumn<TType = unknown> = {
+    header?: (info: ReactTableHeaderContext<TType, unknown>) => JSX.Element | string | null;
+    renderer: (info: ReactTableCellContext<TType, unknown>) => JSX.Element | string | null;
+    meta?: ReactTableColumnMeta<TType, unknown>;
+    size?: number;
+};
+export declare type useTableInternalColumns<TType = unknown> = {
+    rowActions?: useTableInternalColumn<TType>;
+    rowExpansion?: useTableInternalColumn<TType>;
+    rowSelection?: useTableInternalColumn<TType>;
+};
+declare type useTableCommonProps<TType = unknown> = TableFeatureProps & {
+    children: (JSX.Element | boolean | null | undefined)[];
+    data: TType[];
+    id: string;
+    defaultColumnFreezingIndex?: number;
+    defaultRowActiveIndex?: number;
+    defaultRowGroupColumnId?: keyof TType;
+    defaultSettings?: TableSettings;
+    preset?: TablePreset;
+    rowActions?: TableRowActionRenderer<TType>[];
+    rowActionsForGroup?: TableRowActionGroupRenderer<TType>[];
+    rowActionsLength?: number;
+    rowExpansionRenderer?: TableRowExpansionRenderer<TType>;
+    shortcuts?: TableShortcuts<TType>;
+    onRowClick?: TableRowClickHandler<TType>;
+    onRowGoto?: TableRowGotoHandler;
+    onRowSelect?: TableRowSelectHandler<TType>;
+    onChangeFilter?: TableFilterHandler;
+    onChangeSearch?: TODO;
+    onChangeSettings?: TableSettingsHandler;
+    onChangeSort?: TableSortHandler;
+};
+interface useTableClientProps<TType = unknown> extends useTableCommonProps<TType> {
+    length?: never;
+    loadAll?: never;
+    loadPage?: never;
+    pageSize?: never;
+}
+interface useTableServerProps<TType = unknown> extends useTableCommonProps<TType> {
+    length: number | undefined;
+    loadAll: TableServerLoadAllHandler;
+    loadPage: TableServerLoadPageHandler;
+    pageSize?: number;
+}
+export declare type useTableProps<TType = unknown> = useTableClientProps<TType> | useTableServerProps<TType>;
+export declare type TableColumnProps<TType = unknown> = ValueOf<{
+    [Key in keyof TType]: {
+        accessor?: Key;
+        id: string;
+    } & {
+        renderer?: TableColumnRenderer<TType, TType[Key]>;
+        /** Renderer to use if the cell is an aggregate cell and part of a grouped row */
+        aggregate?: TableColumnRendererAggregate<TType, TType[Key]>;
+        control?: TableColumnRendererControl<TType>;
+        footer?: TableColumnRendererFooter<TType[Key]>;
+        header: TableColumnRendererHeader;
+        /** Aggregation function to be used when the column is part of a grouped row */
+        aggregationFn?: 'auto' | ReactTableBuiltInAggregationFn;
+        align?: TableColumnAlignment;
+        className?: TableColumnClassNameHandler<TType>;
+        dataType?: TableColumnDataType;
+        defaultHidden?: boolean;
+        defaultWidth?: TableColumnWidth;
+        enableFiltering?: boolean;
+        enableGrouping?: boolean;
+        enableHiding?: boolean;
+        enableOrdering?: boolean;
+        enablePrinting?: boolean;
+        enableResizing?: boolean;
+        enableSearch?: boolean;
+        enableSorting?: boolean;
+        enableTruncate?: boolean;
+        filters?: TableFilterComparator[];
+        headerClassName?: string;
+        menu?: TableColumnMenu;
+        minWidth?: number;
+        sort?: TableColumnSortDirection;
+        sortFn?: TableColumnSortFn<TType>;
+        tooltip?: string;
+    };
+}>;
+export declare type TableGroupProps = {
+    children: (JSX.Element | boolean | null | undefined)[];
+    header: string;
+    id: string;
+};
+export {};

package/dist/primitives/Table/useTable/features/useTableColumnFreezing.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare function useTableColumnFreezing(isEnabled?: boolean): {
+    isEnabled: boolean;
+    isHorizontallyScrolled: boolean;
+    handleScroll: (event: React.MouseEvent<HTMLTableElement>) => void;
+};

package/dist/primitives/Table/useTable/features/useTableFontSize.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { TableFontSize } from '../../types';
-export declare function useTableFontSize(isEnabled?: boolean, defaultFontSize?: TableFontSize): {
+import { FontSize } from '../../../../types';
+export declare function useTableFontSize(isEnabled?: boolean, defaultFontSize?: FontSize): {
     isEnabled: boolean;
     size: "small" | "medium" | "large";
     setSize: React.Dispatch<React.SetStateAction<"small" | "medium" | "large">>;

package/dist/primitives/Table/useTable/features/useTableFooter.d.ts

@@ -0,0 +1,3 @@
+export declare function useTableFooter(isEnabled?: boolean): {
+    isEnabled: boolean;
+};

package/dist/primitives/Table/useTable/features/useTablePrinting.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 export declare function useTablePrinting(isEnabled: boolean | undefined, defaultIsWarningVisible: boolean | undefined, id: string): {
     isEnabled: boolean;
     isPrinting: boolean;
+    setIsPrinting: React.Dispatch<React.SetStateAction<boolean>>;
     isWarningVisibleForLargeDatasets: boolean;
     setIsWarningVisibleForLargeDatasets: React.Dispatch<React.SetStateAction<boolean>>;
 };

package/dist/primitives/Table/useTable/features/useTableRef.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { Table as ReactTable } from '@tanstack/react-table';
+import { TableRef } from '../../types';
+export declare function useTableRef<TType = unknown>(table: ReactTable<TType>, ref: React.RefObject<TableRef>): void;

package/dist/primitives/Table/useTable/features/useTableRowActions.d.ts

@@ -0,0 +1,6 @@
+import { TableRowActionRenderer } from '../../types';
+export declare function useTableRowActions<TType = unknown>(isEnabled?: boolean, rowActions?: TableRowActionRenderer<TType>[], rowActionsLength?: number): {
+    isEnabled: boolean;
+    rowActions: TableRowActionRenderer<TType>[] | undefined;
+    rowActionsLength: number;
+};

package/dist/primitives/Table/useTable/features/useTableRowActive.d.ts

@@ -8,5 +8,4 @@ export declare function useTableRowActive(isEnabled?: boolean, initialRowActiveI
     setHoverStatePaused: React.Dispatch<React.SetStateAction<boolean>>;
     handleFocus: (event: React.FocusEvent, length: number, scrollToIndex: TableScrollToIndexHandler) => void;
     handleKeyDown: (event: KeyboardEvent, length: number, scrollToIndex: TableScrollToIndexHandler, tableRef?: React.RefObject<TableRef> | undefined) => void;
-    handleMouseCapture: (event: React.MouseEvent, length: number) => void;
 };

package/dist/primitives/Table/useTable/features/useTableRowClick.d.ts

@@ -2,6 +2,6 @@ import React from 'react';
 import { TableRowClickHandler } from '../../types';
 export declare function useTableRowClick<TType = unknown>(isEnabled?: boolean, onRowClick?: TableRowClickHandler<TType>): {
     isEnabled: boolean;
-    handleClick: (event: React.MouseEvent<HTMLDivElement>, data: TType) => void;
+    handleClick: (event: React.MouseEvent<HTMLTableRowElement>, data: TType) => void;
     handleKeyDown: <TType_1 = unknown>(event: KeyboardEvent, data: TType_1) => void;
 };

package/dist/primitives/Table/useTable/features/useTableRowExpansion.d.ts

@@ -0,0 +1,5 @@
+import { TableRowExpansionRenderer } from '../../types';
+export declare function useTableRowExpansion<TType = unknown>(isEnabled?: boolean, rowExpansionRenderer?: TableRowExpansionRenderer<TType>): {
+    isEnabled: boolean;
+    rowExpansionRenderer: TableRowExpansionRenderer<TType> | undefined;
+};

package/dist/primitives/Table/useTable/features/useTableRowGoto.d.ts

@@ -1,5 +1,5 @@
 import { TableRowGotoHandler } from '../../types';
 export declare function useTableRowGoto(isEnabled?: boolean, handler?: TableRowGotoHandler): {
     isEnabled: boolean;
-    handleGoto: TableRowGotoHandler | (() => undefined);
+    handleGoto: TableRowGotoHandler | undefined;
 };

package/dist/primitives/Table/useTable/features/useTableRowGroups.d.ts

@@ -0,0 +1,5 @@
+import { TableRowActionGroupRenderer } from '../../types';
+export declare function useTableRowGroups<TType = unknown>(rowActionsForGroup?: TableRowActionGroupRenderer<TType>[]): {
+    isEnabled: boolean;
+    rowActionsForGroup: TableRowActionGroupRenderer<TType>[] | undefined;
+};

package/dist/primitives/Table/useTable/features/useTableRowSelection.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { Table as ReactTable } from '@tanstack/react-table';
 export declare function useTableRowSelection(isEnabled?: boolean): {
+    isEnabled: boolean;
     handleKeyDown: <TType = unknown>(event: KeyboardEvent, table: ReactTable<TType>) => void;
     lastSelectedRowIndex: React.MutableRefObject<number | undefined>;
 };

package/dist/primitives/Table/useTable/features/useTableSearch.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { Table as ReactTable } from '@tanstack/react-table';
+export declare function useTableSearch(isEnabled?: boolean, defaultEnableGlobalFilter?: boolean): {
+    isEnabled: boolean;
+    enableGlobalFilter: boolean;
+    setEnableGlobalFilter: <TType = unknown>(enabled: boolean, instance: ReactTable<TType>) => void;
+    highlightedColumnIndexes: number[][];
+    setHighlightedColumnIndexes: React.Dispatch<React.SetStateAction<number[][]>>;
+    currentHighlightColumnIndex: number | undefined;
+    setCurrentHighlightColumnIndex: React.Dispatch<React.SetStateAction<number | undefined>>;
+};

package/dist/primitives/Table/useTable/features/useTableServerLoading.d.ts

@@ -1,6 +1,9 @@
-import { TableServerLoadAllHandler, TableServerLoadPageHandler } from '../../types';
-export declare function useTableServerLoading(loadPage?: TableServerLoadPageHandler, loadAll?: TableServerLoadAllHandler): {
+import { TableServerLoadAllHandler, TableServerLoadAllState, TableServerLoadPageHandler } from '../../types';
+export declare function useTableServerLoading(loadPage?: TableServerLoadPageHandler, loadAll?: TableServerLoadAllHandler, pageSize?: number): {
     isEnabled: boolean;
     loadPage: TableServerLoadPageHandler | undefined;
     loadAll: TableServerLoadAllHandler | undefined;
+    loadAllIfNeeded: TableServerLoadAllHandler | undefined;
+    loadAllStatus: TableServerLoadAllState;
+    pageSize: number;
 };

package/dist/primitives/Table/useTable/features/useTableSettings.d.ts

@@ -0,0 +1,3 @@
+import { TableSettings, TableSettingsHandler } from '../../types';
+export declare function useUniqueTableId(tableId: string): string;
+export declare function useTableSettings(isEnabled: boolean | undefined, id: string, defaultSettings: TableSettings | undefined, onChangeSettings: TableSettingsHandler | undefined): [TableSettings, TableSettingsHandler];

package/dist/primitives/Table/useTable/listeners/useTableRowHeightListener.d.ts

@@ -0,0 +1,2 @@
+import { Table as ReactTable } from '@tanstack/react-table';
+export declare function useTableRowHeightListener<TType = unknown>(table: ReactTable<TType>): void;

package/dist/primitives/Table/useTable/listeners/useTableSearchListener.d.ts

@@ -0,0 +1,2 @@
+import { Table as ReactTable } from '@tanstack/react-table';
+export declare function useTableSearchListener<TType = unknown>(table: ReactTable<TType>): void;

package/dist/primitives/Table/useTable/listeners/useTableSettingsListener.d.ts

@@ -0,0 +1,3 @@
+import { Table as ReactTable } from '@tanstack/react-table';
+import { TableSettingsHandler } from '../../types';
+export declare function useTableSettingsListener<TType = unknown>(table: ReactTable<TType>, onChangeSettings: TableSettingsHandler | undefined): void;

package/dist/primitives/Table/useTable/useTable.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="react" />
+import { TableMeta as ReactTableMeta, RowData } from '@tanstack/react-table';
+import { TableColumnAlignment, TableColumnClassNameHandler, TableColumnDataType, TableColumnMenu, TableColumnRendererControl, TableFilterComparator, TableRef, useTableInternalColumns, useTableProps } from '../types';
+import { useTableColumnFreezing } from './features/useTableColumnFreezing';
+import { useTableColumnOrdering } from './features/useTableColumnOrdering';
+import { useTableFooter } from './features/useTableFooter';
+import { useTableFontSize } from './features/useTableFontSize';
+import { useTablePrinting } from './features/useTablePrinting';
+import { useTableRowActions } from './features/useTableRowActions';
+import { useTableRowActive } from './features/useTableRowActive';
+import { useTableRowClick } from './features/useTableRowClick';
+import { useTableRowExpansion } from './features/useTableRowExpansion';
+import { useTableRowGoto } from './features/useTableRowGoto';
+import { useTableRowGroups } from './features/useTableRowGroups';
+import { useTableRowHeight } from './features/useTableRowHeight';
+import { useTableRowSelection } from './features/useTableRowSelection';
+import { useTableSearch } from './features/useTableSearch';
+import { useTableServerLoading } from './features/useTableServerLoading';
+declare module '@tanstack/table-core' {
+    interface TableMeta<TData extends RowData> {
+        columnFreezing: ReturnType<typeof useTableColumnFreezing>;
+        columnOrdering: ReturnType<typeof useTableColumnOrdering>;
+        fontSize: ReturnType<typeof useTableFontSize>;
+        footer: ReturnType<typeof useTableFooter>;
+        printing: ReturnType<typeof useTablePrinting>;
+        rowActions: ReturnType<typeof useTableRowActions>;
+        rowActive: ReturnType<typeof useTableRowActive>;
+        rowClick: ReturnType<typeof useTableRowClick>;
+        rowExpansion: ReturnType<typeof useTableRowExpansion>;
+        rowGoto: ReturnType<typeof useTableRowGoto>;
+        rowGroups: ReturnType<typeof useTableRowGroups>;
+        rowHeight: ReturnType<typeof useTableRowHeight>;
+        rowSelection: ReturnType<typeof useTableRowSelection>;
+        search: ReturnType<typeof useTableSearch>;
+        server: ReturnType<typeof useTableServerLoading>;
+    }
+    interface ColumnMeta<TData extends RowData, TValue> {
+        align?: TableColumnAlignment;
+        className?: TableColumnClassNameHandler<TData>;
+        control?: TableColumnRendererControl<TData>;
+        dataType?: TableColumnDataType;
+        enableOrdering?: boolean;
+        enablePrinting?: boolean;
+        enableTruncate?: boolean;
+        filters?: TableFilterComparator[];
+        header: string;
+        headerClassName?: string;
+        menu?: TableColumnMenu;
+        tooltip?: string;
+    }
+}
+export declare function useTable<TType = unknown, TMeta = {}>(props: useTableProps<TType>, ref: React.RefObject<TableRef>, meta?: Partial<ReactTableMeta<TType>> & TMeta, internalColumns?: useTableInternalColumns<TType>): {
+    instance: import("@tanstack/react-table").Table<TType>;
+    length: number;
+    meta: ReactTableMeta<TType> & TMeta;
+    state: import("@tanstack/react-table").TableState;
+};

package/dist/primitives/Table/useTable/util/columns.d.ts

@@ -1,4 +1,10 @@
 import { ColumnDef as ReactTableColumnDef } from '@tanstack/react-table';
-import { TableFontSize } from '../../types';
-export declare const getCellMinWidth: (fontSize?: TableFontSize) => 57 | 83 | 72;
-export declare function ensureOrdering<TType = unknown>(columns: ReactTableColumnDef<TType>[], internalColumnsPinnedToTheRight: string[], settingsOrder: string[] | undefined): string[];
+import { FontSize } from '../../../../types';
+import { TableColumnDataType } from '../../types';
+export declare function isInternalColumn(id: string | undefined): boolean | undefined;
+export declare const getCellMinWidth: (fontSize?: FontSize) => 57 | 83 | 72;
+export declare function isCellHighlighted(query: string, value: unknown, dataType?: TableColumnDataType): boolean;
+export declare function getCellValueAsString(value: unknown, dataType?: TableColumnDataType): string;
+export declare function ensureOrdering<TType = unknown>(columns: ReactTableColumnDef<TType>[], settingsOrder: string[] | undefined, internalColumnsPinnedToTheRight?: string[]): string[];
+export declare function unfreezeAllExternalColumns(leftPinnedState?: string[]): string[];
+export declare function freezeUptoExternalColumn(index: number, columns: string[]): string[];

package/dist/primitives/Table/useTable/util/columns.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primitives/Table/useTable/util/filtering.d.ts

@@ -0,0 +1,7 @@
+import { Row as ReactTableRow } from '@tanstack/react-table';
+import { TableFilterValue } from '../../types';
+export declare const toLowerCase: (value: string | number) => string;
+export declare const isWeakContains: (left: string | number, right: string | number) => boolean;
+export declare const isWeakEqual: (left: string | number, right: string | number) => boolean;
+export declare function columnFilterFn(value: any, filter: TableFilterValue): boolean;
+export declare function globalFilterFn<TType = unknown>(row: ReactTableRow<TType>, columnId: string, searchQuery: string): boolean;

package/dist/primitives/Table/useTable/util/presets.d.ts

@@ -0,0 +1,2 @@
+import { TableFeatureProps, useTableProps } from '../../types';
+export declare function useTableFeaturePreset<TType = unknown>(props: useTableProps<TType>): TableFeatureProps;

package/dist/primitives/Table/useTable/util/search.d.ts

@@ -0,0 +1,2 @@
+import { Table as ReactTable } from '@tanstack/react-table';
+export declare function resetHighlightedColumnIndexes<TType = unknown>(value: string | undefined, table: ReactTable<TType>): number | undefined;

package/dist/primitives/Table/useTable/util/settings.d.ts

@@ -0,0 +1,13 @@
+import { Table as ReactTable } from '@tanstack/react-table';
+export declare function getSettings<TType = unknown>(table: ReactTable<TType>): {
+    columnOrder: import("@tanstack/react-table").ColumnOrderState | undefined;
+    columnPinning: import("@tanstack/react-table").ColumnPinningState;
+    columnSizing: Record<string, number>;
+    columnVisibility: Record<string, boolean> | undefined;
+    excludeUnmatchedRecordsInSearch: boolean;
+    fontSize: "small" | "medium" | "large" | undefined;
+    grouping: import("@tanstack/react-table").GroupingState | undefined;
+    rowHeight: "medium" | "short" | "tall" | "extra-tall" | undefined;
+    showWarningWhenPrintingLargeDataset: boolean;
+    sorting: import("@tanstack/react-table").SortingState;
+};

package/dist/primitives/Table/useTable/util/setup.d.ts

@@ -0,0 +1,14 @@
+import { TableOptions as ReactTableOptions, ColumnDef as ReactTableColumnDef, ColumnSizingState as ReactTableColumnSizingState, ColumnSort as ReactTableColumnSort, TableState as ReactTableState, VisibilityState as ReactTableVisibilityState } from '@tanstack/react-table';
+import { TableFeatureProps, useTableProps, TableSettings, useTableInternalColumns } from '../../types';
+export declare function mapTableChildrenToColumns<TType = unknown>(props: useTableProps<TType>, settings: TableSettings, options: TableFeatureProps, internalColumns?: useTableInternalColumns<TType>): {
+    columns: ReactTableColumnDef<TType, unknown>[];
+    defaultSizing: Record<string, number>;
+    defaultSorting: ReactTableColumnSort[];
+    defaultVisibility: Record<string, boolean>;
+};
+export declare function configureReactTableOptions<TType = unknown>(options: TableFeatureProps, props: useTableProps<TType>): Partial<ReactTableOptions<TType>>;
+export declare function useReactTableInitialState<TType = unknown>(props: useTableProps<TType>, columns: ReactTableColumnDef<TType>[], persistedSettings: TableSettings, defaults: {
+    defaultSizing: ReactTableColumnSizingState;
+    defaultSorting: ReactTableColumnSort[];
+    defaultVisibility: ReactTableVisibilityState;
+}): Partial<ReactTableState>;

package/dist/primitives/Table/useTable/util/sorting.d.ts

@@ -0,0 +1,2 @@
+import { TableColumnDataType, TableColumnSortFn } from '../../types';
+export declare function getSortingFn<TType = unknown>(dataType?: TableColumnDataType, customFnOrBuiltIn?: TableColumnSortFn<TType>): "text" | "auto" | "alphanumeric" | "alphanumericCaseSensitive" | "textCaseSensitive" | "datetime" | "basic" | ((rowA: any, rowB: any, columnId: any) => 0 | 1 | -1);

package/dist/primitives/Table/useTableDataLoader.d.ts

@@ -0,0 +1,23 @@
+import { TableColumnFilter, TableColumnSort, TableFilterHandler, TableServerLoadPageHandler, TableServerLoadAllHandler, TableSortHandler } from './types';
+export declare const DEFAULT_PAGE_SIZE = 100;
+export declare type useTableDataPageFetcher<TType = unknown> = (pageIndex: number, pageSize: number, sorting: TableColumnSort[], filters: TableColumnFilter[], search: string | undefined) => Promise<{
+    data: TType[];
+    length: number;
+}>;
+export declare type useTableDataAllFetcher<TType = unknown> = (sorting: TableColumnSort[], filters: TableColumnFilter[], search: string | undefined) => Promise<{
+    data: TType[];
+    length: number;
+}>;
+export declare type useTableDataLoaderOptions = {
+    pageSize: number;
+};
+export declare type useTableDataLoaderValues<TType = unknown> = {
+    data: TType[];
+    length: number | undefined;
+    loadAll: TableServerLoadAllHandler;
+    loadPage: TableServerLoadPageHandler;
+    onChangeFilter: TableFilterHandler;
+    onChangeSort: TableSortHandler;
+    pageSize: number;
+};
+export declare function useTableDataLoader<TType = unknown>(fetch: useTableDataPageFetcher<TType>, fetchAll: useTableDataAllFetcher<TType>, options?: useTableDataLoaderOptions): [useTableDataLoaderValues<TType>, () => void];