@economic/taco 2.40.0 → 2.40.2

package/dist/primitives/Table/Core/features/useTableStyleColumnFreezing.d.ts

@@ -0,0 +1,4 @@
+import { Table as ReactTable } from '@tanstack/react-table';
+export declare function useTableStyleColumnFreezing<TType = unknown>(tableId: string, table: ReactTable<TType>): {
+    stylesheet: string;
+};

package/dist/primitives/Table/Core/features/useTableStyleGrid.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { Table as ReactTable } from '@tanstack/react-table';
+import { TableFontSize } from '../../types';
+export declare function useTableStyleGrid<TType = unknown>(tableId: string, table: ReactTable<TType>, fontSize: TableFontSize): {
+    style: React.CSSProperties;
+    stylesheet: string;
+};

package/dist/primitives/Table/Core/listeners/useTableRowActiveListener.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { Table as ReactTable } from '@tanstack/react-table';
+export declare function useTableRowActiveListener<TType = unknown>(table: ReactTable<TType>, tableRef: React.RefObject<HTMLTableElement>): void;

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

@@ -0,0 +1,21 @@
+import React from 'react';
+import { Table as ReactTable, Row as ReactTableRow, Cell as ReactTableCell } from '@tanstack/react-table';
+export declare type useTableRenderers<TType = unknown> = {
+    row: TableRowRenderer<TType>;
+    cell: TableCellRenderer<TType>;
+};
+export declare type TableRowRendererProps<TType = unknown> = {
+    cellRenderer: TableCellRenderer<TType>;
+    index: number;
+    measureRow: (size: number, expansionHeight?: number) => void;
+    row: ReactTableRow<TType>;
+    table: ReactTable<TType>;
+};
+export declare type TableRowRenderer<TType = unknown> = <T = TType>(props: TableRowRendererProps<T>) => JSX.Element;
+export declare type TableCellRendererProps<TType = unknown> = React.TdHTMLAttributes<HTMLTableCellElement> & {
+    cell: ReactTableCell<TType, unknown>;
+    cellRef: React.RefObject<HTMLTableCellElement>;
+    index: number;
+    isHighlighted: true | 'current' | undefined;
+};
+export declare type TableCellRenderer<TType = unknown> = <T = TType>(props: TableCellRendererProps<T>) => JSX.Element;

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

@@ -0,0 +1,28 @@
+/// <reference types="react" />
+import { Table as ReactTable, TableMeta as ReactTableMeta, TableState as ReactTableState } from '@tanstack/react-table';
+import { ScrollToOptions as ReactVirtualScrollToOptions } from '@tanstack/react-virtual';
+import { TableCustomSettingsRenderer, TableEmptyStateRenderer, TableProps } from '../types';
+import { TableRef } from '../types';
+import { useTableRenderers } from './types';
+export declare type useTableReturnValue<TType = unknown> = {
+    id: string;
+    instance: ReactTable<TType>;
+    meta: ReactTableMeta<TType>;
+    props: {
+        customSettings: TableCustomSettingsRenderer | undefined;
+        emptyState: TableEmptyStateRenderer | undefined;
+        toolbarLeft: JSX.Element | undefined;
+        toolbarPanel: JSX.Element | undefined;
+        toolbarRight: JSX.Element | undefined;
+    };
+    ref: React.RefObject<TableRef>;
+    renderer: {
+        rows: (JSX.Element | null)[] | null;
+        style: React.CSSProperties;
+        scrollToIndex: (index: number, options?: ReactVirtualScrollToOptions) => void;
+    };
+    style: React.CSSProperties;
+    stylesheet: string;
+    state: ReactTableState;
+};
+export declare function useTable<TType = unknown, TMeta = {}>(props: TableProps<TType>, externalRef: React.Ref<TableRef>, renderers: useTableRenderers<TType>, meta?: Partial<ReactTableMeta<TType>> & TMeta): useTableReturnValue<TType>;

package/dist/primitives/Table/Core/util/rows.d.ts

@@ -0,0 +1,6 @@
+export declare const ROW_HEIGHT_ESTIMATES: {
+    short: number;
+    medium: number;
+    tall: number;
+    'extra-tall': number;
+};

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

@@ -0,0 +1,381 @@
+/// <reference types="react" />
+import { ColumnFilter as ReactTableColumnFilter, ColumnFiltersState as ReactTableColumnFilterState, ColumnOrderState as ReactTableColumnOrderState, ColumnPinningState as ReactTableColumnPinningState, ColumnSort as ReactTableColumnSort, ColumnSizingState as ReactTableColumnSizingState, VisibilityState as ReactTableColumnVisibilityState, SortingState as ReactTableSortingState, BuiltInAggregationFn as ReactTableBuiltInAggregationFn, BuiltInSortingFn as ReactTableBuiltInSortingFn } from '@tanstack/react-table';
+import { FontSize, FontSizes, StringWithAutocompleteOptions, ValueOf } from '../../types';
+import { MenuItemProps } from '../../components/Menu/components/Item';
+export declare type TableRef = HTMLTableElement & {
+    instance: {
+        resetFiltering: () => void;
+        resetRowExpansion: () => void;
+        resetRowSelection: () => void;
+        resetSorting: () => void;
+    };
+};
+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 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 = ((columnId: string) => React.ReactNode | null)[];
+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;
+    fontSize?: FontSize;
+    invalid?: boolean;
+    onBlur?: (value: any) => void;
+    onFocus?: React.FocusEventHandler;
+    readOnly?: boolean;
+    ref: React.RefObject<HTMLElement> | ((instance: HTMLElement | null | undefined) => void);
+    setValue: (value: any) => void;
+    value: any;
+};
+export declare type TableColumnRendererHeader = string;
+export declare type TableColumnRendererFooter<TType> = (rows: TType[]) => 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, internalRowId: string) => 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 TableRowDragHandler<TType = unknown> = (rows: TType[], showPlaceholder: (string: any) => void, setDataTransfer: (data: string) => void) => void;
+export declare type TableRowDropHandler<TType = unknown> = (event: React.DragEvent, 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';
+export declare type TableRowSelectHandler<TType = unknown> = (rows: TType[]) => void;
+export declare type TableRowWithMetaData<TType = unknown> = TType & {
+    _meta?: {
+        layout?: 'heading' | 'summary' | 'item';
+    };
+};
+export declare type TableShortcutHandlerFn<TType = unknown> = (row: TType) => void;
+export declare type TableShortcutHandlerObject<TType = unknown> = {
+    handler: TableShortcutHandlerFn<TType>;
+    meta?: boolean;
+    shift?: boolean;
+};
+export declare type TableFilterHandler = (filters: TableColumnFilter[]) => void | Promise<void>;
+export declare type TableFontSize = keyof typeof FontSizes;
+export declare type TablePreset = 'complex' | 'list' | 'simple';
+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 TableSearchHandler = (search: string | undefined) => void | Promise<void>;
+export declare type TableServerLoadPageHandler = (pageIndex: number, sorting: TableColumnSort[], filters: TableColumnFilter[]) => Promise<void>;
+export declare type TableServerLoadAllHandler = (sorting: TableColumnSort[], filters: TableColumnFilter[]) => 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 | Promise<void>;
+export declare type TableCustomSettingsRenderer = (props: TableSettings) => React.ReactElement<MenuItemProps>[];
+export declare type TableEmptyStateReason = 'empty' | 'filtering' | 'searching';
+export declare type TableEmptyStateRenderer = (props: {
+    reason: TableEmptyStateReason;
+}) => JSX.Element | null;
+export declare type TableSettings = {
+    columnFilters?: ReactTableColumnFilterState;
+    columnOrder?: ReactTableColumnOrderState;
+    columnPinning?: ReactTableColumnPinningState;
+    columnSizing?: ReactTableColumnSizingState;
+    columnVisibility?: ReactTableColumnVisibilityState;
+    excludeUnmatchedRecordsInSearch?: boolean;
+    fontSize?: TableFontSize;
+    rowHeight?: TableRowHeight;
+    searchQuery?: string;
+    sorting?: ReactTableSortingState;
+};
+export declare type TableEnableSettingsOptions = {
+    columnOrder: boolean;
+    columnPinning: boolean;
+    columnSizing: boolean;
+    columnVisibility: boolean;
+    excludeUnmatchedRecordsInSearch: boolean;
+    fontSize: boolean;
+    grouping: boolean;
+    rowHeight: boolean;
+    sorting: boolean;
+};
+export declare type TableFeatureProps<TType = unknown> = {
+    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 | ((row: TType) => boolean);
+    enableRowDrag?: boolean;
+    enableRowDrop?: boolean;
+    enableRowGoto?: boolean;
+    enableRowHeight?: boolean;
+    enableSaveSettings?: boolean | Partial<TableEnableSettingsOptions>;
+};
+export declare type TableCommonProps<TType = unknown> = TableFeatureProps<TType> & {
+    children: (JSX.Element | boolean | null | undefined)[];
+    data: TType[];
+    id: string;
+    customSettings?: TableCustomSettingsRenderer;
+    defaultColumnFreezingIndex?: number;
+    defaultRowActiveIndex?: number;
+    defaultRowGroupColumnId?: keyof TType;
+    defaultSettings?: TableSettings;
+    emptyState?: TableEmptyStateRenderer;
+    preset?: TablePreset;
+    rowActions?: TableRowActionRenderer<TType>[];
+    rowActionsForGroup?: TableRowActionGroupRenderer<TType>[];
+    rowActionsLength?: number;
+    rowExpansionRenderer?: TableRowExpansionRenderer<TType>;
+    rowIdentityColumnId?: string;
+    shortcuts?: TableShortcuts<TType>;
+    toolbarLeft?: JSX.Element;
+    toolbarRight?: JSX.Element;
+    toolbarPanel?: JSX.Element;
+    onRowClick?: TableRowClickHandler<TType>;
+    onRowDrag?: TableRowDragHandler<TType>;
+    onRowDrop?: TableRowDropHandler<TType>;
+    onRowGoto?: TableRowGotoHandler;
+    onRowSelect?: TableRowSelectHandler<TType>;
+    onChangeFilter?: TableFilterHandler;
+    onChangeSearch?: TableSearchHandler;
+    onChangeSettings?: TableSettingsHandler;
+    onChangeSort?: TableSortHandler;
+};
+export interface TableClientProps<TType = unknown> extends TableCommonProps<TType> {
+    length?: never;
+    loadAll?: never;
+    loadPage?: never;
+    pageSize?: never;
+}
+export interface TableServerProps<TType = unknown> extends TableCommonProps<TType> {
+    length: number | undefined;
+    loadAll: TableServerLoadAllHandler;
+    loadPage: TableServerLoadPageHandler;
+    pageSize?: number;
+}
+export declare type TableProps<TType = unknown> = TableClientProps<TType> | TableServerProps<TType>;
+export declare type TableColumnProps<TType = unknown> = ValueOf<{
+    [Key in keyof TType]: {
+        accessor?: Key;
+        id: StringWithAutocompleteOptions<Key>;
+        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>;
+        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 declare type TableTexts = {
+    columns: {
+        actions: {
+            tooltip: string;
+        };
+        drag: {
+            tooltip: string;
+        };
+        expansion: {
+            collapse: string;
+            collapseAll: string;
+            expand: string;
+            expandAll: string;
+        };
+        menu: {
+            editFilter: string;
+            filter: string;
+            freezeFirstColumn: string;
+            freezeUptoColumn: string;
+            gotoRow: string;
+            hideColumn: string;
+            unfreezeColumns: string;
+            sorting: string;
+            sortingOrder: {
+                ascending: string;
+                descending: string;
+                unsorted: string;
+            };
+        };
+        resize: {
+            tooltip: string;
+        };
+        select: {
+            deselect: string;
+            deselectAll: string;
+            select: string;
+            selectAll: string;
+        };
+    };
+    columnSettings: {
+        button: string;
+        noResults: string;
+        search: string;
+        tooltip: string;
+    };
+    filters: {
+        button: string;
+        buttons: {
+            addFilter: string;
+            clearFilters: string;
+            cancel: string;
+            clear: string;
+            apply: string;
+        };
+        comparators: {
+            contains: string;
+            doesNotContain: string;
+            isEqualTo: string;
+            isNotEqualTo: string;
+            isGreaterThan: string;
+            isLessThan: string;
+            isBetween: string;
+            isEmpty: string;
+            isNotEmpty: string;
+            isBefore: string;
+            isAfter: string;
+            isLessThanOrEqualTo: string;
+            isGreaterThanOrEqualTo: string;
+            isOnOrBefore: string;
+            isOnOrAfter: string;
+            hasAnyOf: string;
+            hasAllOf: string;
+            hasNoneOf: string;
+        };
+        conditions: {
+            and: string;
+            where: string;
+        };
+        emptyFilter: {
+            condition: string;
+            value: string;
+        };
+        hiddenColumn: string;
+        hiddenGroupedColumn: string;
+        tooltip: string;
+        total: string;
+    };
+    fontSize: {
+        tooltip: string;
+        sizes: {
+            small: string;
+            medium: string;
+            large: string;
+        };
+    };
+    footer: {
+        summary: {
+            count: string;
+            records: string;
+            selected: string;
+        };
+    };
+    print: {
+        error: string;
+        loading: string;
+        tooltip: string;
+        warningDialog: {
+            title: string;
+            description: string;
+            checkboxVisibilityLabel: string;
+            cancelButtonText: string;
+            printButtonText: string;
+        };
+        settingsDialog: {
+            title: string;
+            size: string;
+            sizeA5: string;
+            sizeA4: string;
+            sizeA3: string;
+            sizeLetter: string;
+            sizeLegal: string;
+            orientation: string;
+            orientationLandscape: string;
+            orientationPortrait: string;
+            rows: string;
+            rowsAll: string;
+            rowsSelected: string;
+            layout: string;
+            layoutSplitGroups: string;
+        };
+    };
+    rowHeight: {
+        tooltip: string;
+        sizes: {
+            short: string;
+            medium: string;
+            tall: string;
+            extraTall: string;
+        };
+    };
+    search: {
+        excludeUnmatchedResults: string;
+        placeholder: string;
+    };
+    otherOptions: {
+        tooltip: string;
+    };
+};

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

@@ -0,0 +1,24 @@
+import { TableColumnFilter, TableColumnSort, TableFilterHandler, TableServerLoadPageHandler, TableServerLoadAllHandler, TableSortHandler, TableSearchHandler } from './types';
+export declare const DEFAULT_PAGE_SIZE = 100;
+export declare type useTableDataPageFetcher<TType = unknown> = (pageIndex: number, pageSize: number, sorting: TableColumnSort[], filters: TableColumnFilter[]) => Promise<{
+    data: TType[];
+    length: number;
+}>;
+export declare type useTableDataAllFetcher<TType = unknown> = (sorting: TableColumnSort[], filters: TableColumnFilter[]) => 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;
+    onChangeSearch: TableSearchHandler;
+    onChangeSort: TableSortHandler;
+    pageSize: number;
+};
+export declare function useTableDataLoader<TType = unknown>(fetchPage: useTableDataPageFetcher<TType>, fetchAll: useTableDataAllFetcher<TType>, options?: useTableDataLoaderOptions): [useTableDataLoaderValues<TType>, () => void];

package/dist/primitives/Table/useTableManager/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/useTableManager/features/useTableColumnOrdering.d.ts

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

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

@@ -0,0 +1,7 @@
+import React from 'react';
+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/useTableManager/features/useTableFooter.d.ts

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

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

@@ -0,0 +1,15 @@
+import React from 'react';
+declare type TablePrintSettings = {
+    allRows: boolean;
+    orientation: 'portrait' | 'landscape';
+    size: 'A3' | 'A4' | 'A5' | 'letter' | 'legal';
+    splitGroups: boolean;
+};
+export declare function useTablePrinting(isEnabled: boolean | undefined, tableId: string): {
+    isEnabled: boolean;
+    isPrinting: boolean;
+    setIsPrinting: React.Dispatch<React.SetStateAction<boolean>>;
+    settings: TablePrintSettings;
+    setSetting: (key: "allRows" | "orientation" | "size" | "splitGroups", value: any) => void;
+};
+export {};

package/dist/primitives/Table/useTableManager/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/useTableManager/features/useTableRowActive.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { TableScrollToIndexHandler } from '../../types';
+export declare function useTableRowActive(isEnabled?: boolean, initialRowActiveIndex?: number): {
+    isEnabled: boolean;
+    rowActiveIndex: number | undefined;
+    setRowActiveIndex: React.Dispatch<React.SetStateAction<number | undefined>>;
+    rowHoverIndex: number | undefined;
+    setRowHoverIndex: React.Dispatch<React.SetStateAction<number | undefined>>;
+    isHoverStatePaused: boolean;
+    setHoverStatePaused: React.Dispatch<React.SetStateAction<boolean>>;
+    handleFocus: (event: React.FocusEvent, length: number, scrollToIndex: TableScrollToIndexHandler) => void;
+    handleKeyDown: (event: KeyboardEvent, length: number, scrollToIndex: TableScrollToIndexHandler) => void;
+};

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

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

package/dist/primitives/Table/useTableManager/features/useTableRowDrag.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { TableRowDragHandler } from '../../types';
+export declare function useTableRowDrag<TType = unknown>(isEnabled?: boolean, onRowDrag?: TableRowDragHandler<TType>): {
+    isEnabled: boolean;
+    dragging: Record<string, boolean>;
+    setDragging: React.Dispatch<React.SetStateAction<Record<string, boolean>>> | undefined;
+    handleRowDrag: TableRowDragHandler<TType> | undefined;
+};

package/dist/primitives/Table/useTableManager/features/useTableRowDrop.d.ts

@@ -0,0 +1,5 @@
+import { TableRowDropHandler } from '../../types';
+export declare function useTableRowDrop<TType = unknown>(isEnabled: boolean | undefined, onRowDrop: TableRowDropHandler<TType> | undefined): {
+    isEnabled: boolean;
+    handleDrop: TableRowDropHandler<TType> | undefined;
+};

package/dist/primitives/Table/useTableManager/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/useTableManager/features/useTableRowGoto.d.ts

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

package/dist/primitives/Table/useTableManager/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/useTableManager/features/useTableRowHeight.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { TableRowHeight } from '../../types';
+export declare function useTableRowHeight(isEnabled?: boolean, defaultRowHeight?: TableRowHeight): {
+    isEnabled: boolean;
+    height: TableRowHeight;
+    setHeight: React.Dispatch<React.SetStateAction<TableRowHeight>>;
+};

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

@@ -0,0 +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/useTableManager/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/useTableManager/features/useTableServerLoading.d.ts

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

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

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

package/dist/primitives/Table/useTableManager/listeners/useTableDataListener.d.ts

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

package/dist/primitives/Table/useTableManager/listeners/useTableFilterListener.d.ts

@@ -0,0 +1,3 @@
+import { Table as ReactTable } from '@tanstack/react-table';
+import { TableFilterHandler } from '../../types';
+export declare function useTableFilterListener<TType = unknown>(table: ReactTable<TType>, onFilter?: TableFilterHandler): void;

package/dist/primitives/Table/useTableManager/listeners/useTableFontSizeListener.d.ts

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