@economic/taco 2.24.0 → 2.25.0

package/dist/components/Provider/Localization.d.ts

@@ -150,6 +150,8 @@ export declare const defaultLocalisationTexts: {
                 expandAll: string;
             };
             menu: {
+                editFilter: string;
+                filter: string;
                 freezeFirstColumn: string;
                 freezeUptoColumn: string;
                 freezeColumns: (count?: number) => string;

package/dist/components/Report/Report.d.ts

@@ -4,13 +4,13 @@ import { TableRef } from '../../primitives/Table/types';
 import './style.css';
 declare function Column<TType = unknown>(_: ReportColumnProps<TType>): null;
 declare function Group(_: ReportGroupProps): null;
-export declare const Report: (<TType = unknown>(props: (import("../../primitives/Table/types").useTableClientProps<TType> & {
+export declare const Report: (<TType = unknown>(props: (import("../../primitives/Table/types").TableClientProps<TType> & {
     customSettings?: import("./types").ReportCustomSettingsRenderer | undefined;
     emptyState?: import("./types").ReportEmptyStateRenderer | undefined;
     toolbarLeft?: JSX.Element | undefined;
     toolbarRight?: JSX.Element | undefined;
     toolbarPanel?: JSX.Element | undefined;
-} & React.RefAttributes<TableRef>) | (import("../../primitives/Table/types").useTableServerProps<TType> & {
+} & React.RefAttributes<TableRef>) | (import("../../primitives/Table/types").TableServerProps<TType> & {
     customSettings?: import("./types").ReportCustomSettingsRenderer | undefined;
     emptyState?: import("./types").ReportEmptyStateRenderer | undefined;
     toolbarLeft?: JSX.Element | undefined;

package/dist/components/Report/components/Header/Header.d.ts

@@ -4,6 +4,7 @@ import { TableColumnAlignment, TableColumnMenu, TableColumnSortDirection, TableC
 export declare function Header<TType = unknown>(header: ReactTableHeader<TType, unknown>): JSX.Element | null;
 export declare type MemoedHeaderProps = {
     align?: TableColumnAlignment;
+    canFilter: boolean;
     canHide: boolean;
     canGoto: boolean;
     canMeasureSize: boolean;
@@ -18,11 +19,13 @@ export declare type MemoedHeaderProps = {
     hasMenu: boolean;
     id: string;
     index: number;
+    isFiltered: boolean;
     isGroup: boolean;
     isPinned?: ReactTableColumnPinningPosition;
     isPlaceholder: boolean;
     isResizing?: boolean;
     offset?: number;
+    onFilter?: () => void;
     onGoto?: (query: string) => Promise<number>;
     onHide?: (event: unknown) => void;
     onPin?: (index: number | undefined) => void;

package/dist/components/Report/components/Header/components/Menu.d.ts

@@ -1,12 +1,15 @@
 import React from 'react';
 import { TableColumnMenu, TableColumnSortDirection } from '../../../../../primitives/Table/types';
 export declare type HeaderMenuProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    canFilter: boolean;
     canGoto: boolean;
     canHide: boolean;
     canPin: boolean;
     canSort: boolean;
     customMenu?: TableColumnMenu;
     index: number;
+    isFiltered: boolean;
+    onFilter?: () => void;
     onGoto?: (query: string) => Promise<number>;
     onHide?: (event: unknown) => void;
     onPin?: (index: number | undefined) => void;

package/dist/components/Report/components/Toolbar/components/Filters/util.d.ts

@@ -1,2 +1,4 @@
 import { Column as ReactTableColumn } from '@tanstack/react-table';
+import { TableFilter } from '../../../../../../primitives/Table/types';
 export declare function sortByHeader<TType = unknown>(a: ReactTableColumn<TType>, b: ReactTableColumn<TType>): number;
+export declare function isEmptyFilter(filter: TableFilter): boolean;

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

@@ -1,9 +1,9 @@
 /// <reference types="react" />
-import { TableColumnProps, TableGroupProps, TableSettings, useTableProps } from '../../primitives/Table/types';
+import { TableColumnProps, TableGroupProps, TableSettings, TableProps } from '../../primitives/Table/types';
 import { MenuItemProps } from '../Menu/components/Item';
 export type { TableFilterComparator, TableFilterValue, TableFilter, TableColumnAlignment, TableColumnClassNameHandler, TableColumnDataType, TableColumnFilter, TableColumnMenu, TableColumnRenderer, TableColumnRendererAggregate, TableColumnRendererControl, TableColumnRendererControlProps, TableColumnRendererHeader, TableColumnRendererFooter, TableColumnSort, TableColumnSortDirection, TableColumnSortFn, TableColumnWidth, TableRowActionRenderer, TableRowActionGroupRenderer, TableRowClickHandler, TableRowGotoHandler, TableRowHeight, TableRowSelectHandler, TableShortcutHandlerFn, TableShortcutHandlerObject, TableFilterHandler, TableFontSize, TablePreset, TableRowExpansionRenderer, TableScrollToIndexHandler, TableServerLoadPageHandler, TableServerLoadAllHandler, TableServerLoadAllState, TableSettingsHandler, TableShortcuts, TableSortHandler, TableSettings, TableFeatureProps, } from '../../primitives/Table/types';
 export declare type ReportEmptyStateRenderer = () => JSX.Element | null;
-export declare type ReportProps<TType = unknown> = useTableProps<TType> & {
+export declare type ReportProps<TType = unknown> = TableProps<TType> & {
     customSettings?: ReportCustomSettingsRenderer;
     emptyState?: ReportEmptyStateRenderer;
     toolbarLeft?: JSX.Element;

package/dist/components/Select2/Select2.d.ts

@@ -20,24 +20,42 @@ declare type Select2Texts = {
     deselectAllResults: string;
 };
 declare type Select2Props = Omit<React.HTMLAttributes<HTMLButtonElement>, 'children' | 'defaultValue' | 'onChange' | 'value'> & {
+    /** Autofocus Select2 when loaded **/
     autoFocus?: boolean;
+    /** Array of options in Select2 */
     children: Select2Children;
+    /** Initial value of the input in Select2 */
     defaultValue?: Select2Value;
+    /** Set what value should have an empty option in Select2 */
     emptyValue?: Select2OptionValue;
+    /** Whether the Select2 is in a disabled state **/
     disabled?: boolean;
+    /** Draws attention to the Select2 by changing its style and making it visually prominent */
     highlighted?: boolean;
+    /** Whether the Select2 is in an invalid state **/
     invalid?: boolean;
+    /** Whether the Select2 allows selecting multiple values **/
     multiple?: boolean;
+    /** Whether the Select2 is in an invalid state **/
     name?: string;
+    /** Handler called when user chooses an option from the provided options **/
     onChange?: (value: Select2Value) => void;
+    /** Handler called when user creates a new option **/
     onCreate?: Select2CreateHandler;
+    /** Handler called when user deletes an option **/
     onDelete?: Select2DeleteHandler;
+    /** Handler called when user edits an option **/
     onEdit?: Select2EditHandler;
+    /** Whether the Select2 is in a readonly state **/
     readOnly?: boolean;
     required?: boolean;
+    /** Renders select options as tags **/
     tags?: boolean;
+    /** Value of the input in select2 */
     value?: Select2Value;
+    /** Font size of text in Select2 **/
     fontSize?: FontSize;
+    /** Placeholder showed when nothing is selected **/
     placeholder?: string;
 };
 declare type Select2PropsWithStatics = React.ForwardRefExoticComponent<Select2Props & React.RefAttributes<HTMLButtonElement>> & {

package/dist/components/Table/Table.d.ts

@@ -1,7 +1,7 @@
 export * from './components/Table';
 export * from './components/PaginatedTable';
 export * from './components/WindowedTable';
-export type { PaginationHandler, Row, RowIndexPath, RowClickHandler, RowDragHandler, RowCreateHandler, RowCopyHandler, RowDeleteHandler, RowActionHandler, SelectedRowsHandler, SelectedRowsState, SortDirection, SortHandler, SortRule, SortTypes, TableCell, TableColumnProps, TableGroupProps, TableProps, TableRow, TableRef, } from './types';
+export type { PaginationHandler, Row, RowIndexPath, RowClickHandler, RowDragHandler, RowCreateHandler, RowCopyHandler, RowDeleteHandler, RowActionHandler, SelectedRowsHandler, SelectedRowsState, SortDirection, SortHandler, SortRule, SortTypes, LegacyTableCell as TableCell, LegacyTableColumnProps as TableColumnProps, LegacyTableGroupProps as TableGroupProps, LegacyTableProps as TableProps, LegacyTableRow as TableRow, LegacyTableRef as TableRef, } from './types';
 export * from './util/rowIndexPath';
 export * from './hooks/useRowCreation';
 export declare type TableTexts = {

package/dist/components/Table/components/BaseTable.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import './Table.css';
 export declare const DefaultEmptyState: () => React.ReactNode;
-export declare const BaseTable: React.ForwardRefExoticComponent<Partial<import("../types").TableProps<any>> & Partial<import("react-table").TableInstance<{}>> & {
+export declare const BaseTable: React.ForwardRefExoticComponent<Partial<import("../types").LegacyTableProps<any>> & Partial<import("react-table").TableInstance<{}>> & {
     children: JSX.Element;
     headerRef?: React.MutableRefObject<HTMLDivElement | null> | undefined;
     bodyRef?: React.MutableRefObject<HTMLDivElement | null> | undefined;

package/dist/components/Table/hooks/useRowCreation.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { Row, RowIndexPath, TableRef } from '../types';
+import { Row, RowIndexPath, LegacyTableRef } from '../types';
 export declare const insertChildTableRow: <TRow>(data: Row<TRow>[], rowIndexPath?: RowIndexPath, values?: any) => [Row<TRow>[], RowIndexPath];
 export declare const removeChildTableRow: <TRow>(data: Row<TRow>[], rowIndexPath: RowIndexPath) => Row<TRow>[];
 export declare type useTableRowCreation<TRow> = {
@@ -8,4 +8,4 @@ export declare type useTableRowCreation<TRow> = {
     remove: (rowIndexPath: RowIndexPath) => void;
     isCreating: boolean;
 };
-export declare const useTableRowCreation: <TRow>(data: Row<TRow>[], tableRef: React.RefObject<TableRef>) => useTableRowCreation<TRow>;
+export declare const useTableRowCreation: <TRow>(data: Row<TRow>[], tableRef: React.RefObject<LegacyTableRef>) => useTableRowCreation<TRow>;

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

@@ -1,16 +1,16 @@
 import React from 'react';
-import { InternalTable, PaginationHandler, RowActiveHandler, SortHandler, TableProps, TableRef } from '../types';
+import { InternalTable, PaginationHandler, RowActiveHandler, SortHandler, LegacyTableProps, LegacyTableRef } from '../types';
 export declare const useTable: <T extends {}>(props: React.HTMLAttributes<HTMLDivElement> & {
     autoFocus?: boolean | undefined;
-    children: import("../types").TableChildren<T>;
+    children: import("../types").LegacyTableChildren<T>;
     data: import("../types").Row<T>[];
     dangerouslyHijackGlobalKeyboardNavigation?: boolean | undefined;
     emptyStateRenderer?: (() => React.ReactNode) | undefined;
     onRowClick?: import("../types").RowClickHandler<T> | undefined;
     onRowDrag?: import("../types").RowDragHandler<T> | undefined;
     onSelectedRows?: React.Dispatch<React.SetStateAction<Record<number, boolean>>> | undefined;
-    rowClassName?: string | ((row: import("../types").TableRow<T>) => string | undefined) | undefined;
-    rowExpansionRenderer?: ((row: import("../types").TableRow<T>) => React.ReactNode) | undefined;
+    rowClassName?: string | ((row: import("../types").LegacyTableRow<T>) => string | undefined) | undefined;
+    rowExpansionRenderer?: ((row: import("../types").LegacyTableRow<T>) => React.ReactNode) | undefined;
     rowHeight?: number | undefined;
     selectedRows?: Record<number, boolean> | undefined;
     activeIndex?: number | undefined;
@@ -35,4 +35,4 @@ export declare const useTable: <T extends {}>(props: React.HTMLAttributes<HTMLDi
     onRowActive?: RowActiveHandler<T> | undefined;
 } & {
     windowed?: boolean | undefined;
-}, ref: React.RefObject<TableRef>) => InternalTable;
+}, ref: React.RefObject<LegacyTableRef>) => InternalTable;

package/dist/components/Table/hooks/useTableKeyboardNavigation.d.ts

@@ -1,3 +1,3 @@
 import React from 'react';
-import { TableProps } from '../types';
-export declare const useTableKeyboardNavigation: <T extends {}>(props: TableProps<T>, rows: any[], rowProps: any, ref: React.RefObject<HTMLDivElement>) => [number | undefined, (index: number) => void, (event: React.KeyboardEvent<HTMLElement>) => void, (event: React.FocusEvent<HTMLElement>) => void];
+import { LegacyTableProps } from '../types';
+export declare const useTableKeyboardNavigation: <T extends {}>(props: LegacyTableProps<T>, rows: any[], rowProps: any, ref: React.RefObject<HTMLDivElement>) => [number | undefined, (index: number) => void, (event: React.KeyboardEvent<HTMLElement>) => void, (event: React.FocusEvent<HTMLElement>) => void];

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

@@ -7,7 +7,7 @@ export declare type RowIndexPath = string | undefined;
 export declare type Row<TRow extends {}> = TRow & {
     subRows?: Row<TRow>[];
 };
-export declare type TableRow<TRow> = {
+export declare type LegacyTableRow<TRow> = {
     /**
      * Index of the row.
      * Note: This index is relative to the root or parent row if it is a sub row
@@ -36,14 +36,14 @@ export declare type TableRow<TRow> = {
     isEditing?: boolean;
     toggleRowEditing?: () => void;
 };
-export declare type TableCell<TRow> = {
+export declare type LegacyTableCell<TRow> = {
     accessor: string;
     /** Represents the row which renders the specific cell, exposing its properties */
-    row: TableRow<TRow>;
+    row: LegacyTableRow<TRow>;
     /** Access the rendered value in the cell */
     value: any;
 };
-export declare type TableColumnProps<TRow> = {
+export declare type LegacyTableColumnProps<TRow> = {
     /**
      * This string is used to build the data model for your column.
      * It should match one of the properties defined in your `data` object on `Table`,
@@ -64,10 +64,10 @@ export declare type TableColumnProps<TRow> = {
      * It needs to be a render function that can return a transformed version of the existing value,
      * or any valid react node, for e.g. a `div`
      */
-    cellRenderer?: (cellProps: TableCell<TRow>) => React.ReactNode;
+    cellRenderer?: (cellProps: LegacyTableCell<TRow>) => React.ReactNode;
     /** Disable sorting on column */
     disableSorting?: boolean;
-    editRenderer?: (cellProps: TableCell<TRow>) => React.ReactNode;
+    editRenderer?: (cellProps: LegacyTableCell<TRow>) => React.ReactNode;
     /**
      * Specify the width and growth characteristics of a column.
      * This follows the standard flex-box `flex` css property
@@ -96,16 +96,16 @@ export declare type TableColumnProps<TRow> = {
      */
     style?: object;
 };
-export declare type TableGroupProps<TRow> = {
+export declare type LegacyTableGroupProps<TRow> = {
     /** Content of a group should be another `Table.Group` or a `Table.Column` */
-    children: React.ReactElement<TableColumnProps<TRow>> | React.ReactElement<TableColumnProps<TRow>>[];
+    children: React.ReactElement<LegacyTableColumnProps<TRow>> | React.ReactElement<LegacyTableColumnProps<TRow>>[];
     /** Hide the entire group (and columns defined within group) */
     hidden?: boolean;
     /** Text displayed in the group's header */
     title: string;
 };
-export declare type RowClickHandler<TRow> = (row: TableRow<TRow>, event: React.MouseEvent) => void;
-export declare type RowDragHandler<TRow> = (rows: Array<TableRow<TRow>>, showPlaceholder: (placeholder: string) => void, event: React.DragEvent) => void;
+export declare type RowClickHandler<TRow> = (row: LegacyTableRow<TRow>, event: React.MouseEvent) => void;
+export declare type RowDragHandler<TRow> = (rows: Array<LegacyTableRow<TRow>>, showPlaceholder: (placeholder: string) => void, event: React.DragEvent) => void;
 export declare type SortRule<T> = {
     /** Name of the accessor you want to sort */
     accessor: IdType<T>;
@@ -116,22 +116,22 @@ export declare type SelectedRowsState = Record<number, boolean>;
 export declare type SelectedRowsHandler = React.Dispatch<React.SetStateAction<SelectedRowsState>>;
 export declare type SortHandler<T> = (sortRules: SortRule<T>[] | undefined, sortedData?: T[]) => void;
 export declare type PaginationHandler = (pageNumber: number, pageSize: number) => void;
-export declare type RowCreateHandler<TRow> = (parentRow: TableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
-export declare type RowEditHandler<TRow> = (row: TableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
-export declare type RowCopyHandler<TRow> = (row: TableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
-export declare type RowDeleteHandler<TRow> = (row: TableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
-export declare type RowActiveHandler<TRow> = (row: TableRow<TRow>) => void;
+export declare type RowCreateHandler<TRow> = (parentRow: LegacyTableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowEditHandler<TRow> = (row: LegacyTableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowCopyHandler<TRow> = (row: LegacyTableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowDeleteHandler<TRow> = (row: LegacyTableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowActiveHandler<TRow> = (row: LegacyTableRow<TRow>) => void;
 export declare type RowAction<TRow> = {
-    disabled?: ((row: TableRow<TRow>) => boolean) | boolean;
-    icon: ((row: TableRow<TRow>) => IconName) | IconName;
-    onClick: (row: TableRow<TRow>, event: React.MouseEvent<HTMLElement>) => void;
-    text: ((row: TableRow<TRow>) => React.ReactNode) | React.ReactNode;
-    tooltip?: ((row: TableRow<TRow>) => string) | string;
+    disabled?: ((row: LegacyTableRow<TRow>) => boolean) | boolean;
+    icon: ((row: LegacyTableRow<TRow>) => IconName) | IconName;
+    onClick: (row: LegacyTableRow<TRow>, event: React.MouseEvent<HTMLElement>) => void;
+    text: ((row: LegacyTableRow<TRow>) => React.ReactNode) | React.ReactNode;
+    tooltip?: ((row: LegacyTableRow<TRow>) => string) | string;
     showOnRow?: boolean;
-    visible?: ((row: TableRow<TRow>) => boolean) | boolean;
+    visible?: ((row: LegacyTableRow<TRow>) => boolean) | boolean;
 };
 export declare type RowActionHandler<TRow> = RowAction<TRow> | undefined | null | boolean;
-export declare type TableProps<TRow> = React.HTMLAttributes<HTMLDivElement> & {
+export declare type LegacyTableProps<TRow> = React.HTMLAttributes<HTMLDivElement> & {
     /** Autofocus the table when loaded */
     autoFocus?: boolean;
     /**
@@ -139,7 +139,7 @@ export declare type TableProps<TRow> = React.HTMLAttributes<HTMLDivElement> & {
      * Read about `ForwardedGenericTableWithStatics` for more details.
      * *Note* that there can also be children that are rendered conditionally
      */
-    children: TableChildren<TRow>;
+    children: LegacyTableChildren<TRow>;
     /** Provide data to be displayed in your table */
     data: Row<TRow>[];
     /**
@@ -166,9 +166,9 @@ export declare type TableProps<TRow> = React.HTMLAttributes<HTMLDivElement> & {
      * Provide a className for rows.
      * It can be a `string` or a render function that is given the properties of the row and returns a `string`
      */
-    rowClassName?: string | ((row: TableRow<TRow>) => string | undefined);
+    rowClassName?: string | ((row: LegacyTableRow<TRow>) => string | undefined);
     /** Show extra content below each row */
-    rowExpansionRenderer?: (row: TableRow<TRow>) => React.ReactNode;
+    rowExpansionRenderer?: (row: LegacyTableRow<TRow>) => React.ReactNode;
     /** Give the row a specific height */
     rowHeight?: number;
     /**
@@ -220,7 +220,7 @@ export declare type TableProps<TRow> = React.HTMLAttributes<HTMLDivElement> & {
     /** Handler called when a row is made active */
     onRowActive?: RowActiveHandler<TRow>;
 };
-export declare type TableRef = HTMLDivElement & {
+export declare type LegacyTableRef = HTMLDivElement & {
     instance: {
         toggleAllRowsExpanded: any;
         toggleHideAllColumns: any;
@@ -232,39 +232,39 @@ export declare type TableRef = HTMLDivElement & {
         toggleSortBy: any;
     };
 };
-export declare type ForwardedGenericTableWithStatics = React.ForwardRefExoticComponent<TableProps<any> & React.RefAttributes<HTMLDivElement>> & {
+export declare type ForwardedGenericTableWithStatics = React.ForwardRefExoticComponent<LegacyTableProps<any> & React.RefAttributes<HTMLDivElement>> & {
     /** Represents a column in your table */
-    Column: <TRow>(props: TableColumnProps<TRow>) => JSX.Element | null;
+    Column: <TRow>(props: LegacyTableColumnProps<TRow>) => JSX.Element | null;
     /**
      * Container for columns.
      * Visually this adds a column above and spans all group children.
      * *Note* that groups can only be nested two levels deep
      */
-    Group: <TRow>(props: TableGroupProps<TRow>) => JSX.Element | null;
-} & (<TRow>(props: TableProps<TRow> & {
+    Group: <TRow>(props: LegacyTableGroupProps<TRow>) => JSX.Element | null;
+} & (<TRow>(props: LegacyTableProps<TRow> & {
     ref?: React.Ref<HTMLDivElement>;
 }) => JSX.Element);
-export declare type TableChild<TRow> = React.ReactElement<TableColumnProps<TRow>> | React.ReactElement<TableGroupProps<TRow>> | boolean | null;
-export declare type TableChildren<TRow> = TableChild<TRow> | TableChild<TRow>[];
+export declare type LegacyTableChild<TRow> = React.ReactElement<LegacyTableColumnProps<TRow>> | React.ReactElement<LegacyTableGroupProps<TRow>> | boolean | null;
+export declare type LegacyTableChildren<TRow> = LegacyTableChild<TRow> | LegacyTableChild<TRow>[];
 /** @internal */
-export declare type InternalTableColumn = TableColumnProps<any> & ColumnInstance & UseSortByColumnProps<{}> & {
+export declare type InternalTableColumn = LegacyTableColumnProps<any> & ColumnInstance & UseSortByColumnProps<{}> & {
     className?: string;
 };
 /** @internal */
-export declare type InternalTableCell = TableCell<any> & Cell & {
+export declare type InternalTableCell = LegacyTableCell<any> & Cell & {
     column: InternalTableColumn;
 };
 /** @internal */
-export declare type InternalTableRow = TableRow<any> & BaseRow & UseExpandedRowProps<{}> & UseRowSelectRowProps<{}> & UseRowStateRowProps<{}>;
+export declare type InternalTableRow = LegacyTableRow<any> & BaseRow & UseExpandedRowProps<{}> & UseRowSelectRowProps<{}> & UseRowStateRowProps<{}>;
 /** @internal */
-export declare type InternalBaseTable = Partial<TableProps<any>> & Partial<TableInstance> & {
+export declare type InternalBaseTable = Partial<LegacyTableProps<any>> & Partial<TableInstance> & {
     children: JSX.Element;
     headerRef?: React.MutableRefObject<HTMLDivElement | null>;
     bodyRef?: React.MutableRefObject<HTMLDivElement | null>;
 };
 /** @internal */
 export declare type InternalTable = {
-    rowProps: Pick<TableProps<any>, 'inlineEditingUniqueId' | 'onRowClick' | 'rowClassName' | 'rowExpansionRenderer'> & {
+    rowProps: Pick<LegacyTableProps<any>, 'inlineEditingUniqueId' | 'onRowClick' | 'rowClassName' | 'rowExpansionRenderer'> & {
         activeIndex?: number;
         setActiveIndex?: any;
         rowHeight: number | undefined;

package/dist/components/Table/util/sortTypes.d.ts

@@ -1,4 +1,4 @@
-import { SortTypes, TableRow } from '../types';
-declare type SortHandler<T> = (rowA: TableRow<T>, rowB: TableRow<T>, columnId: string) => 0 | 1 | -1;
+import { SortTypes, LegacyTableRow } from '../types';
+declare type SortHandler<T> = (rowA: LegacyTableRow<T>, rowB: LegacyTableRow<T>, columnId: string) => 0 | 1 | -1;
 export declare const sortTypes: (locale: string) => Record<SortTypes, SortHandler<any>>;
 export {};

package/dist/components/Table/util.d.ts

@@ -1,8 +1,8 @@
-import { TableRow, TableChildren, InternalTableRow, SortRule } from './types';
+import { LegacyTableRow, LegacyTableChildren, InternalTableRow, SortRule } from './types';
 import { SortingRule } from 'react-table';
-export declare const sanitizeRowProps: (row: InternalTableRow, rowExpansionRenderer: any) => TableRow<any>;
-export declare const getColumnsFromChildren: (children: TableChildren<any>, rowExpansionRenderer: any) => {
-    columns: (import("./types").TableColumnProps<any> & import("react-table").ColumnInstance<{}> & import("react-table").UseSortByColumnProps<{}> & {
+export declare const sanitizeRowProps: (row: InternalTableRow, rowExpansionRenderer: any) => LegacyTableRow<any>;
+export declare const getColumnsFromChildren: (children: LegacyTableChildren<any>, rowExpansionRenderer: any) => {
+    columns: (import("./types").LegacyTableColumnProps<any> & import("react-table").ColumnInstance<{}> & import("react-table").UseSortByColumnProps<{}> & {
         className?: string | undefined;
     } & {
         disableSortBy: boolean | undefined;

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

@@ -1,19 +1,19 @@
 import React from 'react';
 import { RowData } from '@tanstack/react-table';
 import { Table3ColumnAlignment, Table3ColumnRenderer, Table3Props, Table3ColumnHeaderMenu, Table3ColumnControlRenderer, Table3ColumnDataType, Table3ColumnClassNameHandler, Table3ColumnFooterRenderer, TableStrategy, Table3FilterComparator, Table3Settings, Table3Ref } from '../types';
-import { useTableRowActive } from '../../../primitives/Table/useTable/features/useTableRowActive';
-import { useTableRowHeight } from '../../../primitives/Table/useTable/features/useTableRowHeight';
-import { useTableFontSize } from '../../../primitives/Table/useTable/features/useTableFontSize';
+import { useTableRowActive } from '../../../primitives/Table/useTableManager/features/useTableRowActive';
+import { useTableRowHeight } from '../../../primitives/Table/useTableManager/features/useTableRowHeight';
+import { useTableFontSize } from '../../../primitives/Table/useTableManager/features/useTableFontSize';
 import { useRowDrag } from './features/useRowDrag';
 import { useColumnFreezing } from './features/useColumnFreezing';
-import { useTableRowSelection } from '../../../primitives/Table/useTable/features/useTableRowSelection';
-import { useTableServerLoading } from '../../../primitives/Table/useTable/features/useTableServerLoading';
-import { useTableRowClick } from '../../../primitives/Table/useTable/features/useTableRowClick';
-import { useTableColumnOrdering } from '../../../primitives/Table/useTable/features/useTableColumnOrdering';
+import { useTableRowSelection } from '../../../primitives/Table/useTableManager/features/useTableRowSelection';
+import { useTableServerLoading } from '../../../primitives/Table/useTableManager/features/useTableServerLoading';
+import { useTableRowClick } from '../../../primitives/Table/useTableManager/features/useTableRowClick';
+import { useTableColumnOrdering } from '../../../primitives/Table/useTableManager/features/useTableColumnOrdering';
 import { useRowDrop } from './features/useRowDrop';
 import { useEditing } from './features/useEditing';
 import { usePrinting } from './features/usePrinting';
-import { useTableRowGoto } from '../../../primitives/Table/useTable/features/useTableRowGoto';
+import { useTableRowGoto } from '../../../primitives/Table/useTableManager/features/useTableRowGoto';
 import { useSearch } from './features/useSearch';
 import { useRowActions } from './features/useRowActions';
 import { Table3Validation } from './features/useValidation';

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

@@ -203,6 +203,8 @@ export declare type Table3Texts = {
             expandAll: string;
         };
         menu: {
+            editFilter: string;
+            filter: string;
             freezeFirstColumn: string;
             freezeUptoColumn: string;
             gotoRow: string;

package/dist/esm/packages/taco/src/components/Menu/components/Trigger.js

@@ -1,11 +1,21 @@
 import { forwardRef, useEffect, createElement } from 'react';
 import { useMergedRef } from '../../../hooks/useMergedRef.js';
+import { createCustomKeyboardEvent } from '../../../utils/input.js';
 import { useCurrentMenu } from '../Context.js';
 import { Trigger as Trigger$1 } from '@radix-ui/react-dropdown-menu';
 
 const Trigger = /*#__PURE__*/forwardRef(function MenuTrigger(props, ref) {
   const menu = useCurrentMenu();
   const internalRef = useMergedRef(ref);
+  const preventArrowDownShortcut = event => {
+    var _internalRef$current, _internalRef$current2;
+    const isRenderedInTable = !!((_internalRef$current = internalRef.current) !== null && _internalRef$current !== void 0 && _internalRef$current.closest('[data-taco="table2-body"]'));
+    const isRenderedInReport = !!((_internalRef$current2 = internalRef.current) !== null && _internalRef$current2 !== void 0 && _internalRef$current2.closest('[data-taco="report-body"]'));
+    if ((isRenderedInTable || isRenderedInReport) && event.key === 'ArrowDown') {
+      var _internalRef$current3, _internalRef$current4;
+      internalRef === null || internalRef === void 0 ? void 0 : (_internalRef$current3 = internalRef.current) === null || _internalRef$current3 === void 0 ? void 0 : (_internalRef$current4 = _internalRef$current3.parentNode) === null || _internalRef$current4 === void 0 ? void 0 : _internalRef$current4.dispatchEvent(createCustomKeyboardEvent(event));
+    }
+  };
   useEffect(() => {
     if (internalRef.current) {
       menu === null || menu === void 0 ? void 0 : menu.setMinWidth(internalRef.current.getBoundingClientRect().width);
@@ -13,7 +23,8 @@ const Trigger = /*#__PURE__*/forwardRef(function MenuTrigger(props, ref) {
   }, [internalRef]);
   return /*#__PURE__*/createElement(Trigger$1, Object.assign({}, props, {
     asChild: true,
-    ref: internalRef
+    ref: internalRef,
+    onKeyDown: preventArrowDownShortcut
   }));
 });
 

package/dist/esm/packages/taco/src/components/Menu/components/Trigger.js.map

@@ -1 +1 @@
-{"version":3,"file":"Trigger.js","sources":["../../../../../../../../src/components/Menu/components/Trigger.tsx"],"sourcesContent":["import * as React from 'react';\nimport * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';\nimport { useMergedRef } from '../../../hooks/useMergedRef';\nimport { useCurrentMenu } from '../Context';\n\nexport type MenuTriggerProps = Omit<React.HTMLAttributes<HTMLButtonElement>, 'children'> & {\n    children: React.ReactElement;\n};\n\nexport const Trigger = React.forwardRef(function MenuTrigger(props: MenuTriggerProps, ref: React.Ref<HTMLButtonElement>) {\n    const menu = useCurrentMenu();\n    const internalRef = useMergedRef<HTMLButtonElement>(ref);\n\n    React.useEffect(() => {\n        if (internalRef.current) {\n            menu?.setMinWidth(internalRef.current.getBoundingClientRect().width);\n        }\n    }, [internalRef]);\n\n    return <DropdownMenuPrimitive.Trigger {...props} asChild ref={internalRef} />;\n});\n"],"names":["Trigger","React","MenuTrigger","props","ref","menu","useCurrentMenu","internalRef","useMergedRef","current","setMinWidth","getBoundingClientRect","width","DropdownMenuPrimitive","asChild"],"mappings":";;;;;MASaA,OAAO,gBAAGC,UAAgB,CAAC,SAASC,WAAWA,CAACC,KAAuB,EAAEC,GAAiC;EACnH,MAAMC,IAAI,GAAGC,cAAc,EAAE;EAC7B,MAAMC,WAAW,GAAGC,YAAY,CAAoBJ,GAAG,CAAC;EAExDH,SAAe,CAAC;IACZ,IAAIM,WAAW,CAACE,OAAO,EAAE;MACrBJ,IAAI,aAAJA,IAAI,uBAAJA,IAAI,CAAEK,WAAW,CAACH,WAAW,CAACE,OAAO,CAACE,qBAAqB,EAAE,CAACC,KAAK,CAAC;;GAE3E,EAAE,CAACL,WAAW,CAAC,CAAC;EAEjB,oBAAON,cAACY,SAA6B,oBAAKV,KAAK;IAAEW,OAAO;IAACV,GAAG,EAAEG;KAAe;AACjF,CAAC;;;;"}
+{"version":3,"file":"Trigger.js","sources":["../../../../../../../../src/components/Menu/components/Trigger.tsx"],"sourcesContent":["import * as React from 'react';\nimport * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';\nimport { useMergedRef } from '../../../hooks/useMergedRef';\nimport { useCurrentMenu } from '../Context';\nimport { createCustomKeyboardEvent } from '../../../utils/input';\n\nexport type MenuTriggerProps = Omit<React.HTMLAttributes<HTMLButtonElement>, 'children'> & {\n    children: React.ReactElement;\n};\n\nexport const Trigger = React.forwardRef(function MenuTrigger(props: MenuTriggerProps, ref: React.Ref<HTMLButtonElement>) {\n    const menu = useCurrentMenu();\n    const internalRef = useMergedRef<HTMLButtonElement>(ref);\n\n    const preventArrowDownShortcut = (event: React.KeyboardEvent) => {\n        const isRenderedInTable = !!internalRef.current?.closest('[data-taco=\"table2-body\"]');\n        const isRenderedInReport = !!internalRef.current?.closest('[data-taco=\"report-body\"]');\n\n        if ((isRenderedInTable || isRenderedInReport) && event.key === 'ArrowDown') {\n            internalRef?.current?.parentNode?.dispatchEvent(\n                createCustomKeyboardEvent(event as React.KeyboardEvent<HTMLInputElement>)\n            );\n        }\n    };\n\n    React.useEffect(() => {\n        if (internalRef.current) {\n            menu?.setMinWidth(internalRef.current.getBoundingClientRect().width);\n        }\n    }, [internalRef]);\n\n    return <DropdownMenuPrimitive.Trigger {...props} asChild ref={internalRef} onKeyDown={preventArrowDownShortcut} />;\n});\n"],"names":["Trigger","React","MenuTrigger","props","ref","menu","useCurrentMenu","internalRef","useMergedRef","preventArrowDownShortcut","event","isRenderedInTable","_internalRef$current","current","closest","isRenderedInReport","_internalRef$current2","key","_internalRef$current3","_internalRef$current4","parentNode","dispatchEvent","createCustomKeyboardEvent","setMinWidth","getBoundingClientRect","width","DropdownMenuPrimitive","asChild","onKeyDown"],"mappings":";;;;;;MAUaA,OAAO,gBAAGC,UAAgB,CAAC,SAASC,WAAWA,CAACC,KAAuB,EAAEC,GAAiC;EACnH,MAAMC,IAAI,GAAGC,cAAc,EAAE;EAC7B,MAAMC,WAAW,GAAGC,YAAY,CAAoBJ,GAAG,CAAC;EAExD,MAAMK,wBAAwB,GAAIC,KAA0B;;IACxD,MAAMC,iBAAiB,GAAG,CAAC,GAAAC,oBAAA,GAACL,WAAW,CAACM,OAAO,cAAAD,oBAAA,eAAnBA,oBAAA,CAAqBE,OAAO,CAAC,2BAA2B,CAAC;IACrF,MAAMC,kBAAkB,GAAG,CAAC,GAAAC,qBAAA,GAACT,WAAW,CAACM,OAAO,cAAAG,qBAAA,eAAnBA,qBAAA,CAAqBF,OAAO,CAAC,2BAA2B,CAAC;IAEtF,IAAI,CAACH,iBAAiB,IAAII,kBAAkB,KAAKL,KAAK,CAACO,GAAG,KAAK,WAAW,EAAE;MAAA,IAAAC,qBAAA,EAAAC,qBAAA;MACxEZ,WAAW,aAAXA,WAAW,wBAAAW,qBAAA,GAAXX,WAAW,CAAEM,OAAO,cAAAK,qBAAA,wBAAAC,qBAAA,GAApBD,qBAAA,CAAsBE,UAAU,cAAAD,qBAAA,uBAAhCA,qBAAA,CAAkCE,aAAa,CAC3CC,yBAAyB,CAACZ,KAA8C,CAAC,CAC5E;;GAER;EAEDT,SAAe,CAAC;IACZ,IAAIM,WAAW,CAACM,OAAO,EAAE;MACrBR,IAAI,aAAJA,IAAI,uBAAJA,IAAI,CAAEkB,WAAW,CAAChB,WAAW,CAACM,OAAO,CAACW,qBAAqB,EAAE,CAACC,KAAK,CAAC;;GAE3E,EAAE,CAAClB,WAAW,CAAC,CAAC;EAEjB,oBAAON,cAACyB,SAA6B,oBAAKvB,KAAK;IAAEwB,OAAO;IAACvB,GAAG,EAAEG,WAAW;IAAEqB,SAAS,EAAEnB;KAA4B;AACtH,CAAC;;;;"}

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

@@ -83,6 +83,8 @@ const defaultLocalisationTexts = {
         expandAll: 'Expand all rows'
       },
       menu: {
+        editFilter: 'Edit filter',
+        filter: 'Filter',
         freezeFirstColumn: 'Freeze the first column',
         freezeUptoColumn: `Freeze first [TOTAL] columns`,
         freezeColumns: (count = 1) => count === 1 ? 'Freeze the first column' : `Freeze first ${count} columns`,