@economic/taco 2.0.0-alpha.173 → 2.0.0-alpha.6

package/dist/components/Table2/hooks/useTable.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import { OnChangeFn, RowData } from '@tanstack/react-table';
+import { RowClickHandler, RowDensity, Table2Children, Table2Props } from '../types';
+import { ColumnOffsetState } from '../types';
+import { ActiveRowHandler, ActiveRowMoveHandler } from './useActiveRow';
+import { useEditMode } from './useEditMode';
+declare module '@tanstack/table-core' {
+    interface TableMeta<TData extends RowData> {
+        activeRowIndex: number;
+        setActiveRowIndex: ActiveRowHandler;
+        moveToPreviousRow: ActiveRowMoveHandler<TData>;
+        moveToNextRow: ActiveRowMoveHandler<TData>;
+        columnOffsets: ColumnOffsetState;
+        enableRowDensity: boolean;
+        rowDensity: RowDensity;
+        setRowDensity: OnChangeFn<RowDensity>;
+        enableRowDragging: boolean;
+        dragging: Record<string, boolean>;
+        setDragging: OnChangeFn<Record<string, boolean>>;
+        enableColumnFreezing: boolean;
+        enableColumnReordering: boolean;
+        enableColumnHiding: boolean;
+        shouldPauseSortingAndFiltering: boolean;
+        setShouldPauseSortingAndFiltering: OnChangeFn<boolean>;
+        shouldPauseHoverState: boolean;
+        setShouldPauseHoverState: OnChangeFn<boolean>;
+        frozenColumnsCount: number;
+        setFrozenColumnsCount: OnChangeFn<number>;
+        onRowClick?: RowClickHandler<TData>;
+        editMode: useEditMode;
+        dataColumnStartOffset: number;
+        dataColumnEndOffset: number;
+        shouldDisableTableActions: boolean;
+        setShouldDisableTableActions: OnChangeFn<boolean>;
+        focussableColumnIndexes: number[];
+        addFocussableColumnIndex: (index: number) => void;
+        resetFocussableColumnIndexes: () => void;
+        tableRef: React.RefObject<HTMLDivElement>;
+        lastSortedOrFilteredRows: React.MutableRefObject<Array<any>>;
+    }
+}
+export declare function useTable<TType = any>(children: Table2Children, props: Table2Props<TType>, ref: React.RefObject<HTMLDivElement>): {
+    rows: any;
+    table: import("@tanstack/react-table").Table<any>;
+    footers: Record<string, import("../types").Table2ColumnFooterRenderer>;
+};

package/dist/components/Table2/hooks/useTableShortcuts.d.ts

@@ -0,0 +1,2 @@
+import { Table2Shortcuts } from '../types';
+export declare function useTableShortcuts<TType = any>(shortcuts: Table2Shortcuts<TType> | undefined, activeRow: TType): void;

package/dist/components/Table2/hooks/useVirtualiser.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { OnChangeFn } from '@tanstack/react-table';
+import { VirtualItem } from 'react-virtual';
+declare type ExpandedRowSizeState = Record<string, number>;
+declare type useVirtualiser = {
+    virtualiser: {
+        virtualItems: VirtualItem[];
+        totalSize: number;
+        scrollToOffset: (index: number, options?: any) => void;
+        scrollToIndex: (index: number, options?: any) => void;
+        measure: () => void;
+    };
+    virtualiserOffsets: {
+        top: number;
+        bottom: number;
+    };
+    setExpandedRowSizes: OnChangeFn<ExpandedRowSizeState>;
+};
+export declare const useVirtualiser: ({ rows, table }: {
+    rows: any;
+    table: any;
+}, tableRef: React.RefObject<HTMLElement>) => useVirtualiser;
+export {};

package/dist/components/Table2/types.d.ts

@@ -0,0 +1,148 @@
+import React from 'react';
+import { BuiltInSortingFn, ColumnFiltersState, ColumnOrderState, ColumnSizingState, OnChangeFn, Row, SortingState, VisibilityState } from '@tanstack/react-table';
+import { DialogProps } from '../Dialog/Dialog';
+import { IconName } from '../Icon/Icon';
+import { MenuProps } from '../Menu/Menu';
+export declare enum Table2FilterComparator {
+    Contains = 0,
+    DoesNotContain = 1,
+    IsEqualTo = 2,
+    IsNotEqualTo = 3,
+    IsGreaterThan = 4,
+    IsLessThan = 5,
+    IsBetween = 6,
+    IsOneOf = 7,
+    IsNoneOf = 8,
+    IsAllOf = 9,
+    IsEmpty = 10,
+    IsNotEmpty = 11
+}
+export declare type Table2Filter<TType = any> = {
+    comparator?: Table2FilterComparator;
+    value: TType | TType[];
+};
+export declare type ColumnOffsetState = Record<string, number | undefined>;
+export declare type RowDensity = 'compact' | 'normal' | 'comfortable' | 'spacious';
+export declare type CellAlignment = 'left' | 'center' | 'right';
+export declare type SortDirection = 'asc' | 'desc';
+export declare type ColumnDataType = 'auto' | 'alphanumeric' | 'alphanumericCaseSensitive' | 'datetime' | 'boolean';
+export declare type Table2ColumnHeaderRenderer<TType = any> = (value: any, row: TType) => JSX.Element | string | null;
+export declare type Table2ColumnHeaderMenu = (props: Partial<MenuProps>) => JSX.Element;
+export declare type Table2ColumnFooterRenderer = (values: any[]) => JSX.Element | string | null;
+export declare type Table2ColumnControlProps = {
+    className?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    onBlur: (newValue?: any) => Promise<void>;
+    onFocus: React.FocusEventHandler;
+    readOnly?: boolean;
+    ref: React.RefObject<HTMLElement>;
+    setValue: (value: any) => void;
+    value: any;
+    'data-inline-editing-component'?: 'true';
+};
+export declare type Table2ColumnControlRenderer<TType = any> = ((props: Table2ColumnControlProps, row?: TType) => JSX.Element) | 'datepicker' | 'input' | 'switch';
+export declare type SortFn<TType = unknown> = ((rowA: TType, rowB: TType, columnId: string) => -1 | 0 | 1) | BuiltInSortingFn | 'auto';
+export declare type Table2ColumnProps<TType = any> = {
+    accessor: string;
+    align?: CellAlignment;
+    className?: string | ((row: Row<TType>) => string);
+    control?: Table2ColumnControlRenderer<TType>;
+    dataType?: ColumnDataType;
+    defaultActiveColumnIndex?: number;
+    defaultActiveRowIndex?: number;
+    defaultHidden?: boolean;
+    disableFiltering?: boolean;
+    disableHiding?: boolean;
+    disableReordering?: boolean;
+    disableResizing?: boolean;
+    disableSorting?: boolean;
+    defaultWidth?: number | 'grow';
+    header: string;
+    headerClassName?: string;
+    footer?: Table2ColumnFooterRenderer;
+    renderer?: Table2ColumnHeaderRenderer<TType>;
+    menu?: Table2ColumnHeaderMenu;
+    minWidth?: number;
+    sort?: SortDirection;
+    sortFn?: SortFn<TType>;
+    tooltip?: string;
+};
+export declare type Table2ActionProps<TType> = {
+    dialog?: (rows: TType[], resetSelectedRows: () => void) => (props: Partial<DialogProps>) => JSX.Element;
+    disabled?: boolean | ((rows: TType[]) => boolean);
+    icon: IconName | ((rows: TType[]) => IconName);
+    onClick?: (rows: TType[], resetSelectedRows: () => void) => void;
+    text: string | ((rows: TType[]) => string);
+    visible?: boolean | ((rows: TType[]) => boolean);
+};
+export declare type Table2RowActionRenderer<TType = unknown> = (row: TType) => JSX.Element | null;
+export declare type Table2Settings = {
+    columnFilters?: ColumnFiltersState;
+    columnOrder?: ColumnOrderState;
+    columnSizing?: ColumnSizingState;
+    columnVisibility?: VisibilityState;
+    frozenColumnCount?: number;
+    globalFilter?: string;
+    rowDensity?: RowDensity;
+    sorting?: SortingState;
+};
+export declare type RowClickHandler<TType = any> = (row: TType) => void;
+export declare type RowDragHandler<TType = any> = (rows: TType[], showPlaceholder: (string: any) => void, setDataTransfer: (data: string) => void) => void;
+export declare type RowDropHandler<TType = any> = (event: React.DragEvent, row: TType) => void;
+export declare type RowSelectionHandler<TType = any> = (rows: TType[], allSelected: boolean) => void;
+export declare type RowExpansionRenderer<TType = any> = (row: TType) => (() => JSX.Element) | null;
+export declare type SortHandler = OnChangeFn<SortingState>;
+export declare type SettingsHandler = OnChangeFn<Table2Settings>;
+export declare type SaveHandlerErrorResponse = Record<string, string | undefined | null> | null;
+export declare type SaveHandler<TType = any> = (row: TType, accessor: string) => Promise<SaveHandlerErrorResponse | void>;
+export declare type DataColumnIndexes = {
+    dataColumnStartOffset: number;
+    dataColumnEndOffset: number;
+};
+export declare type Table2Children<TType = any> = (React.ReactElement<Table2ColumnProps<TType>> | boolean | null | undefined)[];
+export declare type Table2ShortcutHandlerFn<TType = any> = (row: TType) => void;
+export declare type Table2ShortcutHandlerObject<TType = any> = {
+    handler: Table2ShortcutHandlerFn<TType>;
+    meta?: boolean;
+    shift?: boolean;
+};
+export declare type Table2Shortcuts<TType = any> = Record<string, Table2ShortcutHandlerFn<TType> | Table2ShortcutHandlerObject<TType>>;
+export declare type Table2Props<TType = any> = Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> & {
+    actionsForRow?: Table2RowActionRenderer<TType>[];
+    actionsForRowLength?: number;
+    children: Table2Children;
+    className?: string;
+    data: TType[];
+    defaultActiveRowIndex?: number;
+    disableColumnFiltering?: boolean;
+    disableColumnHiding?: boolean;
+    disableColumnFreezing?: boolean;
+    disableColumnReordering?: boolean;
+    disableColumnResizing?: boolean;
+    disableRowDensity?: boolean;
+    disableRowExpansion?: boolean;
+    disableRowSelection?: boolean;
+    disableMultipleRowSelection?: boolean;
+    disableSearch?: boolean;
+    disableSorting?: boolean;
+    emptyState?: () => JSX.Element;
+    expandedRowRenderer?: RowExpansionRenderer<TType>;
+    length?: number;
+    loadMore?: () => Promise<void>;
+    manualColumnFiltering?: boolean;
+    manualSearch?: boolean;
+    manualSorting?: boolean;
+    onChangeSettings?: SettingsHandler;
+    onRowClick?: RowClickHandler<TType>;
+    onRowDrag?: RowDragHandler<TType>;
+    onRowDrop?: RowDropHandler<TType>;
+    onRowSelect?: RowSelectionHandler<TType>;
+    onSave?: SaveHandler<TType>;
+    shortcuts?: Table2Shortcuts<TType>;
+    toolbarLeft?: JSX.Element;
+    toolbarRight?: JSX.Element;
+    settings?: Table2Settings;
+    _experimentalActionsForTable?: Table2ActionProps<TType>[];
+    _experimentalActionsForTableSummary?: (rows: TType[]) => JSX.Element | string;
+};

package/dist/components/Table2/utilities/cell.d.ts

@@ -0,0 +1,14 @@
+import { Column } from '@tanstack/react-table';
+import { CellAlignment, RowDensity } from '../types';
+export declare const getCellSizingClasses: (density?: RowDensity, editing?: boolean) => string;
+export declare const getCellAlignmentClasses: (alignment?: CellAlignment) => {
+    'justify-start text-left': boolean;
+    'justify-end text-right': boolean;
+    'justify-center text-center': boolean;
+};
+export declare const getFrozenShadowClasses: (column: Column<any, any>, frozenColumns: string[], isHorizontallyOffset: boolean) => {
+    'shadow-[6px_0px_6px_rgb(0_0_0/8%),1px_0px_0px_theme(colors.grey.300)]': boolean;
+    'shadow-[1px_0px_0px_theme(colors.grey.300)]': boolean;
+};
+export declare const focussableNodeNames: string[];
+export declare const isKeyboardFocusableElement: (element: Element) => boolean;

package/dist/components/Table2/utilities/columns.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { ColumnDef, DisplayColumnDef } from '@tanstack/react-table';
+import { RowDragHandler, RowExpansionRenderer } from '../types';
+import { LocalizationTexts } from '../../Provider/Localization';
+export declare const COLUMN_ID_FOR_DRAGGABLE = "__draggable";
+export declare const COLUMN_ID_FOR_SELECTION = "__select";
+export declare const COLUMN_ID_FOR_EXPANSION = "__expansion";
+export declare const COLUMN_ID_FOR_ACTIONS = "__actions";
+export declare const isInternalFrozenColumn: (id: string) => boolean;
+export declare const isInternalColumn: (id: string) => boolean;
+export declare const MIN_COLUMN_SIZE = 80;
+export declare function createRowDraggableColumn<TType = any>(onRowDrag: RowDragHandler<TType>, texts: LocalizationTexts): DisplayColumnDef<TType, any>;
+export declare function createRowSelectionColumn<TType = any>(enableMultipleRowSelection: boolean, lastSelectedRowIndex: React.MutableRefObject<number | undefined>, onRowDrag: RowDragHandler<TType> | undefined, tableRef: React.RefObject<HTMLDivElement>, texts: LocalizationTexts): DisplayColumnDef<TType, any>;
+export declare function createRowExpansionColumn<TType = any>(expandedRowRenderer: RowExpansionRenderer<TType>, texts: LocalizationTexts): DisplayColumnDef<TType, any>;
+export declare function createRowActionsColumn<TType = any>(rowActions: any, rowActionsLength: any, texts: LocalizationTexts): DisplayColumnDef<TType, any>;
+export declare function ensureOrdering<TType = unknown>(columns: ColumnDef<TType>[], settingsOrder: string[] | undefined): string[];

package/dist/components/Table2/utilities/filterFn.d.ts

@@ -0,0 +1,3 @@
+import { Table2Filter } from '../types';
+export declare const globalFilterFn: (value: string, query: string) => boolean;
+export declare const columnFilterFn: (value: any, filter: Table2Filter) => boolean;

package/dist/components/Table3/Table3.d.ts

@@ -1,11 +1,12 @@
 import React from 'react';
 import { Table3ColumnProps, Table3Props, Table3Ref } from './types';
 import './style.css';
-export { useTableData } from './hooks/useTableData';
-export type { useTable3DataFetcher, useTable3DataOptions, useTableDataValues } from './hooks/useTableData';
 declare type Table3WithStatics<TType = unknown> = React.ForwardRefExoticComponent<Table3Props<TType>> & {
     Column: (props: Table3ColumnProps) => null;
 } & (<TType>(props: Table3Props<TType> & {
     ref?: React.Ref<Table3Ref>;
 }) => JSX.Element);
 export declare const Table3: Table3WithStatics<unknown>;
+export { useTable3DataLoader } from './hooks/useTableDataLoader';
+export type { useTable3DataFetcher, useTable3DataOptions, useTableDataValues } from './hooks/useTableDataLoader';
+export type { Table3Ref, Table3Props, Table3Preset, Table3Settings, Table3SettingsAdapter, Table3RowHeight, Table3FilterComparator, Table3FilterHandler, Table3SearchHandler, Table3LoadPageHandler, Table3LoadAllHandler, Table3RowGotoHandler, Table3SortHandler, Table3Shortcuts, Table3ShortcutHandlerFn, Table3ShortcutHandlerObject, Table3FontSize, Table3SortDirection, Table3SortFn, Table3RowActionRenderer, Table3RowSelectionHandler, Table3RowExpansionRenderer, Table3RowDropHandler, Table3RowDragHandler, Table3RowClickHandler, Table3ColumnProps, Table3ColumnAlignment, Table3ColumnDataType, Table3ColumnHeaderMenu, Table3ColumnClassNameHandler, Table3ColumnFooterRenderer, Table3ColumnRenderer, Table3ColumnControlRenderer, Table3ColumnControlProps, } from './types';

package/dist/components/Table3/components/columns/cell/DisplayCell.d.ts

@@ -1,13 +1,13 @@
 import React from 'react';
 import { CellContext } from '@tanstack/react-table';
-import { ColumnAlignment } from '../../../types';
+import { Table3ColumnAlignment } from '../../../types';
 export declare type DisplayCellProps<TType = unknown> = CellContext<TType, unknown> & {
     children?: string | JSX.Element;
     className?: string;
 };
 export declare function DisplayCell<TType = unknown>(props: DisplayCellProps<TType>): JSX.Element;
 export declare type MemoedDisplayCellProps<TType = unknown> = {
-    align?: ColumnAlignment;
+    align?: Table3ColumnAlignment;
     children: JSX.Element | string | null;
     className?: string;
     data: TType;

package/dist/components/Table3/components/columns/footer/Footer.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="react" />
 import { ColumnMeta, HeaderContext } from '@tanstack/react-table';
-import { ColumnAlignment, Table3ColumnFooterRenderer } from '../../../types';
+import { Table3ColumnAlignment, Table3ColumnFooterRenderer } from '../../../types';
 export declare type FooterProps<TType = unknown> = HeaderContext<TType, unknown> & {
     renderer?: Table3ColumnFooterRenderer<TType>;
 };
 export declare function Footer<TType = unknown>(props: FooterProps<TType>): JSX.Element;
 export declare type MemoedFooterProps<TType = unknown> = Omit<FooterProps<TType>, 'header' | 'column' | 'scrollToIndex'> & {
-    align?: ColumnAlignment;
+    align?: Table3ColumnAlignment;
     id: string;
     index: number;
     isFrozen: boolean;

package/dist/components/Table3/components/columns/header/Header.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="react" />
 import { ColumnMeta, HeaderContext } from '@tanstack/react-table';
-import { ColumnAlignment, SortDirection, TableStrategy } from '../../../types';
+import { Table3ColumnAlignment, Table3SortDirection, TableStrategy } from '../../../types';
 export declare type HeaderProps<TType = unknown> = HeaderContext<TType, unknown> & {
     children?: string | JSX.Element;
 };
 export declare function Header<TType = unknown>(props: HeaderProps<TType>): JSX.Element;
 export declare type MemoedHeaderProps<TType = unknown> = Omit<HeaderProps<TType>, 'column' | 'header'> & {
-    align?: ColumnAlignment;
+    align?: Table3ColumnAlignment;
     canFreeze: boolean;
     canHide: boolean;
     canResize: boolean;
@@ -23,5 +23,5 @@ export declare type MemoedHeaderProps<TType = unknown> = Omit<HeaderProps<TType>
     onResize: (event: unknown) => void;
     onSort: (event: unknown) => void;
     scrollToIndex: TableStrategy['scrollToIndex'];
-    sortDirection: false | SortDirection;
+    sortDirection: false | Table3SortDirection;
 };

package/dist/components/Table3/components/columns/header/SortIndicator.d.ts

@@ -1,11 +1,11 @@
 import React from 'react';
-import { SortDirection } from '../../../types';
+import { Table3SortDirection } from '../../../types';
 declare type SortIndicatorProps = {
-    direction: false | SortDirection;
+    direction: false | Table3SortDirection;
 };
 export declare function SortIndicator(props: SortIndicatorProps): any;
 export declare const getAriaSort: (direction: any) => any;
-export declare function getSortAttributes(toggleSorting: (event: unknown) => void, sortDirection: false | SortDirection): {
+export declare function getSortAttributes(toggleSorting: (event: unknown) => void, sortDirection: false | Table3SortDirection): {
     'aria-sort': any;
     onClick: (event: React.MouseEvent) => void;
 };

package/dist/components/Table3/components/columns/styles.d.ts

@@ -1,4 +1,4 @@
-import { ColumnAlignment } from '../../types';
+import { Table3ColumnAlignment } from '../../types';
 export declare const MIN_COLUMN_SIZE = 80;
-export declare const getCellAlignmentClasses: (alignment?: ColumnAlignment) => string;
+export declare const getCellAlignmentClasses: (alignment?: Table3ColumnAlignment) => string;
 export declare const getInputAppearanceClassnames: () => string;

package/dist/components/Table3/hooks/useTable.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { RowData } from '@tanstack/react-table';
-import { ColumnAlignment, Table3ColumnRenderer, Table3Props, Table3ColumnHeaderMenu, Table3ColumnControlRenderer, ColumnDataType, Table3ColumnClassNameHandler, Table3ColumnFooterRenderer, TableStrategy } from '../types';
+import { Table3ColumnAlignment, Table3ColumnRenderer, Table3Props, Table3ColumnHeaderMenu, Table3ColumnControlRenderer, Table3ColumnDataType, Table3ColumnClassNameHandler, Table3ColumnFooterRenderer, TableStrategy } from '../types';
 import { useCurrentRow } from './features/useCurrentRow';
 import { usePauseHoverState } from './features/usePauseHoverState';
 import { useRowHeight } from './features/useRowHeight';
@@ -34,10 +34,10 @@ declare module '@tanstack/table-core' {
         search: ReturnType<typeof useSearch>;
     }
     interface ColumnMeta<TData extends RowData, TValue> {
-        align?: ColumnAlignment;
+        align?: Table3ColumnAlignment;
         className?: Table3ColumnClassNameHandler<TData>;
         control?: Table3ColumnControlRenderer<TData>;
-        dataType?: ColumnDataType;
+        dataType?: Table3ColumnDataType;
         defaultWidth?: number;
         enableOrdering: boolean;
         enableSearch: boolean;

package/dist/components/Table3/hooks/useTableDataLoader.d.ts

@@ -0,0 +1,23 @@
+import { ColumnFilter, Table3ColumnSort, Table3FilterHandler, Table3LoadAllHandler, Table3LoadPageHandler, Table3SearchHandler, Table3SortHandler } from '../types';
+export declare type useTable3DataFetcher<TType = unknown> = (pageIndex: number, pageSize: number, sorting: Table3ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<{
+    data: TType[];
+    length: number;
+}>;
+export declare type useTable3AllDataFetcher<TType = unknown> = (sorting: Table3ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<{
+    data: TType[];
+    length: number;
+}>;
+export declare type useTable3DataOptions = {
+    pageSize: number;
+};
+export declare type useTableDataValues<TType = unknown> = {
+    data: TType[];
+    length: number | undefined;
+    loadAll: Table3LoadAllHandler;
+    loadPage: Table3LoadPageHandler;
+    onFilter: Table3FilterHandler;
+    onSearch: Table3SearchHandler;
+    onSort: Table3SortHandler;
+    pageSize: number;
+};
+export declare function useTable3DataLoader<TType = unknown>(fetch: useTable3DataFetcher<TType>, fetchAll: useTable3AllDataFetcher<TType>, options?: useTable3DataOptions): useTableDataValues<TType>;

package/dist/components/Table3/types.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="react" />
-import { ColumnFilter as RTColumnFilter, ColumnFiltersState, ColumnOrderState, ColumnPinningState, ColumnSizingState, ColumnSort as RTColumnSort, SortingState, VisibilityState, BuiltInSortingFn } from '@tanstack/react-table';
+import { ColumnFilter as RTColumnFilter, ColumnFiltersState, ColumnOrderState, ColumnPinningState, ColumnSizingState, ColumnSort as RTTableColumnSort, SortingState, VisibilityState, BuiltInSortingFn } from '@tanstack/react-table';
 import { MenuProps } from '../Menu/Menu';
-export declare type SortDirection = 'asc' | 'desc';
-export declare type SortFn<TType = unknown> = ((rowA: TType, rowB: TType, columnId: string) => -1 | 0 | 1) | BuiltInSortingFn | 'auto';
+export declare type Table3SortDirection = 'asc' | 'desc';
+export declare type Table3SortFn<TType = unknown> = ((rowA: TType, rowB: TType, columnId: string) => -1 | 0 | 1) | BuiltInSortingFn | 'auto';
 export declare type Table3ColumnRenderer<TValue = unknown, TType = unknown> = (value: TValue, row: TType) => JSX.Element | string | null;
 export declare type Table3ColumnFooterRenderer<TValue = unknown> = (values: TValue[]) => JSX.Element | string | null;
 export declare type Table3ColumnClassNameHandler<TType = unknown> = string | ((row: TType) => string);
-export declare type ColumnAlignment = 'left' | 'center' | 'right';
-export declare type ColumnDataType = 'auto' | 'alphanumeric' | 'alphanumericCaseSensitive' | 'datetime' | 'boolean';
+export declare type Table3ColumnAlignment = 'left' | 'center' | 'right';
+export declare type Table3ColumnDataType = 'auto' | 'alphanumeric' | 'alphanumericCaseSensitive' | 'datetime' | 'boolean';
 export declare type Table3ColumnHeaderMenu = (props: Partial<MenuProps>) => JSX.Element;
 export declare type Table3ColumnControlProps = {
     className?: string;
@@ -23,10 +23,10 @@ export declare type Table3ColumnControlProps = {
 export declare type Table3ColumnControlRenderer<TType = unknown> = ((props: Table3ColumnControlProps, row?: TType) => JSX.Element) | 'datepicker' | 'input' | 'switch';
 export declare type Table3ColumnProps<TType = unknown> = {
     accessor: string;
-    align?: ColumnAlignment;
+    align?: Table3ColumnAlignment;
     className?: Table3ColumnClassNameHandler<TType>;
     control?: Table3ColumnControlRenderer<TType>;
-    dataType?: ColumnDataType;
+    dataType?: Table3ColumnDataType;
     defaultHidden?: boolean;
     defaultWidth?: number | 'grow';
     enableFiltering?: boolean;
@@ -41,8 +41,8 @@ export declare type Table3ColumnProps<TType = unknown> = {
     headerClassName?: string;
     menu?: Table3ColumnHeaderMenu;
     renderer?: Table3ColumnRenderer<unknown, TType>;
-    sort?: SortDirection;
-    sortFn?: SortFn<TType>;
+    sort?: Table3SortDirection;
+    sortFn?: Table3SortFn<TType>;
     tooltip?: string;
 };
 export declare type DeprecatedRowDensity = 'compact' | 'normal' | 'comfortable' | 'spacious';
@@ -54,7 +54,6 @@ export declare type Table3RowDropHandler<TType = any> = (event: React.DragEvent,
 export declare type Table3RowExpansionRenderer<TType = unknown> = (row: TType) => (() => JSX.Element) | null;
 export declare type Table3RowSelectionHandler<TType = unknown> = (rows: TType[]) => void;
 export declare type Table3RowActionRenderer<TType = unknown> = (row: TType) => JSX.Element;
-export declare type Table3RenderStrategy = 'static' | 'virtual';
 export declare type Table3Preset = 'display' | 'editable';
 export declare type Table3Settings = {
     columnFilters?: ColumnFiltersState;
@@ -95,11 +94,11 @@ export declare type Table3Filter = {
 export declare type ColumnFilter = RTColumnFilter;
 export declare type Table3FilterHandler = (filters: ColumnFilter[]) => void;
 export declare type Table3SearchHandler = (query: string | undefined) => Promise<void>;
-export declare type Table3LoadPageHandler = (pageIndex: number, sorting: ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<void>;
-export declare type Table3LoadAllHandler = (sorting: ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<void>;
-export declare type Table3RowGotoHandler = (column: string, query: string, sorting: ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<number>;
-export declare type ColumnSort = RTColumnSort;
-export declare type Table3SortHandler = (sorting: ColumnSort[]) => void;
+export declare type Table3LoadPageHandler = (pageIndex: number, sorting: Table3ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<void>;
+export declare type Table3LoadAllHandler = (sorting: Table3ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<void>;
+export declare type Table3RowGotoHandler = (column: string, query: string, sorting: Table3ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<number>;
+export declare type Table3ColumnSort = RTTableColumnSort;
+export declare type Table3SortHandler = (sorting: Table3ColumnSort[]) => void;
 export declare type TableStrategy = {
     renderBody: () => JSX.Element | JSX.Element[] | null;
     scrollToIndex: (index: number, options?: {
@@ -133,7 +132,7 @@ export declare type Table3Options = {
     enableSearch: boolean;
     enableSorting: boolean;
 };
-export declare type CommonTable3Props<TType = unknown> = Partial<Table3Options> & {
+export declare type Table3CommonProps<TType = unknown> = Partial<Table3Options> & {
     actionsForRow?: Table3RowActionRenderer<TType>[];
     actionsForRowLength?: number;
     children: (React.ReactElement<Table3ColumnProps<TType>> | boolean | null | undefined)[];
@@ -159,19 +158,19 @@ export declare type CommonTable3Props<TType = unknown> = Partial<Table3Options>
     toolbarLeft?: JSX.Element;
     toolbarRight?: JSX.Element;
 };
-interface ClientTable3Props<TType = unknown> extends CommonTable3Props<TType> {
+interface Table3ClientProps<TType = unknown> extends Table3CommonProps<TType> {
     length?: never;
     loadPage?: never;
     loadAll?: never;
     pageSize?: never;
 }
-interface ServerTable3Props<TType = unknown> extends CommonTable3Props<TType> {
+interface Table3ServerProps<TType = unknown> extends Table3CommonProps<TType> {
     length: number | undefined;
     loadPage: Table3LoadPageHandler;
     loadAll: Table3LoadAllHandler;
     pageSize?: number;
 }
-export declare type Table3Props<TType = unknown> = ClientTable3Props<TType> | ServerTable3Props<TType>;
+export declare type Table3Props<TType = unknown> = Table3ClientProps<TType> | Table3ServerProps<TType>;
 export declare type Table3Ref = HTMLDivElement & {
     instance: {
         resetFiltering: () => void;

package/dist/esm/packages/taco/src/components/Provider/Localization.js

@@ -68,6 +68,116 @@ const defaultLocalisationTexts = {
     newSubRow: 'New row (shift + n)',
     loading: 'Loading...'
   },
+  table2: {
+    columns: {
+      resize: {
+        tooltip: 'Resize column'
+      },
+      actions: {
+        tooltip: 'Other actions'
+      },
+      drag: {
+        tooltip: 'Drag row'
+      },
+      expansion: {
+        collapse: 'Collapse row',
+        collapseAll: 'Collapse all rows',
+        expand: 'Expand row',
+        expandAll: 'Expand all rows'
+      },
+      select: {
+        deselect: 'Deselect row',
+        deselectAll: 'Deselect all rows',
+        select: 'Select row',
+        selectAll: 'Select all rows'
+      },
+      menu: {
+        hideColumn: 'Hide column',
+        freezeColumns: (count = 1) => count === 1 ? 'Freeze the first column' : `Freeze first ${count} columns`,
+        unfreezeColumns: 'Unfreeze all columns'
+      }
+    },
+    columnSettings: {
+      search: 'Search column...',
+      tooltip: 'Column settings',
+      button: 'Columns',
+      noResults: 'No results'
+    },
+    editing: {
+      button: 'Edit',
+      tooltip: 'Edit',
+      tooltipDisabled: 'There are no visible columns that support editing',
+      rowIndicator: {
+        rowWillMove: 'Row will move due to sorting',
+        rowWillBeHidden: 'Row will hide due to filtering',
+        rowWillMoveReasonSearch: 'Due to a search filter applied to this table, this row will be hidden as soon as you select another row',
+        rowWillMoveReasonFilter: "Due to a filter applied to the column '[COLUMN]', this row will be hidden as soon as you select another row",
+        rowWillMoveReasonSorting: "Due to sorting applied to the column '[COLUMN]', this row will move position as soon as you select another row"
+      }
+    },
+    filters: {
+      button: 'Filters',
+      buttons: {
+        addNewFilter: 'Add new filter',
+        clearFilters: 'Clear all filters'
+      },
+      comparators: {
+        contains: 'Contains',
+        doesNotContain: 'Does not contain',
+        isEqualTo: 'Is',
+        isNotEqualTo: 'Is not',
+        isGreaterThan: 'Is greater than',
+        isLessThan: 'Is less than',
+        isBetween: 'Is between',
+        isOneOf: 'Is one of',
+        isNoneOf: 'Is none of',
+        isAllOf: 'Is all of',
+        isEmpty: 'Is empty',
+        isNotEmpty: 'Is not empty'
+      },
+      conditions: {
+        and: 'And',
+        where: 'Where'
+      },
+      emptyFilter: {
+        condition: 'Condition',
+        value: 'Value'
+      },
+      tooltip: 'Apply filters',
+      total: 'Viewing [CURRENT] of [TOTAL]'
+    },
+    footer: {
+      summary: {
+        records: 'Records:',
+        selected: 'Records selected:'
+      }
+    },
+    rowDensity: {
+      tooltip: 'Row density',
+      compact: 'compact',
+      normal: 'normal',
+      comfortable: 'comfortable',
+      spacious: 'spacious'
+    },
+    search: {
+      placeholder: 'Search...'
+    },
+    shortcuts: {
+      tooltip: 'View keyboard shortcuts',
+      search: 'Search',
+      filter: 'Filter',
+      previousRow: 'Previous row',
+      nextRow: 'Next row',
+      editCell: 'Edit cell',
+      previousColumn: 'Previous column',
+      nextColumn: 'Next column',
+      rowClick: 'Activate current row',
+      selectRow: 'Select current row',
+      selectAllRows: 'Select all rows',
+      expandRow: 'Expand current row',
+      collapseRow: 'Collapse current row'
+    }
+  },
   table3: {
     columns: {
       actions: {