@aivenio/aquarium 2.2.0 → 2.3.1

package/dist/src/molecules/ItemList/ItemList.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import { type InfiniteListProps } from '../../../src/molecules/List/List';
+import { type DataTableRowId, type ItemListColumn, type MenuColumnType } from '../../../src/utils/table/types';
+import { type SortState } from '../../../src/utils/table/useSortState';
+export type Item = Record<string, unknown> & {
+    /**
+     * Assigned ID for each data row.
+     * Used as a key. Use something unqiue derived from the data, not index.
+     */
+    id: DataTableRowId;
+    /**
+     * Reserved key for each item, will be used to render sub-items
+     */
+    items?: Item[];
+};
+type NotMenuColumn<I extends Item> = Exclude<ItemListColumn<I>, MenuColumnType<I>>;
+export type Columns<I extends Item> = Array<NotMenuColumn<I>> | [...Array<NotMenuColumn<I>>, MenuColumnType<I>];
+type ItemListProps<I extends Item> = InfiniteListProps & {
+    /**
+     * Array of column definitions that correspond to the data.
+     */
+    columns: Columns<I>;
+    /**
+     * Array of data to be displayed.
+     */
+    items: I[];
+    /**
+     * Optional callback function that is called when user clicks column header to change table sorting.
+     * If provided, no sortig will be done by the component.
+     */
+    onSortChanged?: (sortState: SortState) => void;
+    /**
+     * Determines if table header should stick to top when scrolling.
+     * @default true
+     */
+    sticky?: boolean;
+};
+export declare const ItemList: <I extends Item>({ columns, items, onSortChanged, sticky, ...infiniteProps }: ItemListProps<I>) => React.JSX.Element;
+export {};

package/dist/src/molecules/ItemList/ItemList.js

@@ -0,0 +1,72 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React from 'react';
+import { List } from '../../../src/molecules/List/List';
+import { Template } from '../../../src/molecules/Template/Template';
+import { DataList } from '../../../src/atoms/DataList/DataList';
+import { sortByColumn } from '../../../src/utils/table/sortByColumn';
+import { cellProps, columnHasSort, } from '../../../src/utils/table/types';
+import { useSortState } from '../../../src/utils/table/useSortState';
+import { DataListCell } from '../DataList/DataListComponents';
+export const ItemList = (_a) => {
+    var { columns, items, onSortChanged, sticky } = _a, infiniteProps = __rest(_a, ["columns", "items", "onSortChanged", "sticky"]);
+    const templateColumns = columns.map((column) => { var _a; return (_a = column.width) !== null && _a !== void 0 ? _a : 'auto'; });
+    const [sortState, setSortState] = useSortState();
+    const sortedItems = onSortChanged ? items : sortByColumn(items, columns, sortState); // If onSortChanged is provided its assumed that the parent is managing the sorting
+    return (React.createElement(Template, { className: "Aquarium-ItemList", columns: templateColumns, role: "table" },
+        React.createElement(DataList.Row, { header: true }, columns.map((column) => {
+            if (columnHasSort(column)) {
+                return (React.createElement(DataList.SortCell, Object.assign({ sticky: sticky, direction: (sortState === null || sortState === void 0 ? void 0 : sortState.headerName) === column.headerName ? sortState.direction : 'none', onClick: () => {
+                        const newState = 
+                        // In case column is already sorted, either ascending or descending
+                        sortState && sortState.headerName === column.headerName
+                            ? sortState.direction === 'ascending'
+                                ? // In case column is sorted ascending, sort it descending
+                                    { headerName: column.headerName, direction: 'descending' }
+                                : // In case column is sorted ascending, sort it descending
+                                    undefined
+                            : // Nothing is set, sort it ascending
+                                { headerName: column.headerName, direction: 'ascending' };
+                        setSortState(newState);
+                        onSortChanged === null || onSortChanged === void 0 ? void 0 : onSortChanged(newState);
+                    } }, cellProps(column)), column.headerName));
+            }
+            return (React.createElement(DataList.HeadCell, Object.assign({}, cellProps(column), { sticky: sticky }), column.headerName));
+        })),
+        React.createElement(Rows, Object.assign({ columns: columns, items: sortedItems, level: 0 }, infiniteProps))));
+};
+const Rows = (_a) => {
+    var { columns, items, level, isLastGroup } = _a, infiniteProps = __rest(_a, ["columns", "items", "level", "isLastGroup"]);
+    return (React.createElement(List, Object.assign({}, (level === 0 ? infiniteProps : {}), { items: items, renderItem: (item, itemIndex) => {
+            const hasSubItems = item.items && item.items.length > 0;
+            const isLastItem = itemIndex === items.length - 1;
+            /**
+             * No divider if
+             * 1. It's the last item in the main level. Between main level items there should be divider except for the last one.
+             * 2. Level is greater than 0 and we are either in last group or not last item. Inside groups there should never be dividers except if its the last item.
+             * 3. It has sub-items. If there are sub-items it means that this item is a group and should not have divider.
+             */
+            const noDivider = (level === 0 && isLastItem) || (level > 0 && (isLastGroup || !isLastItem)) || hasSubItems;
+            return (React.createElement(React.Fragment, { key: item.id },
+                React.createElement(DataList.Row, { noDivider: noDivider },
+                    React.createElement(List, { items: columns, renderItem: (column, columnIndex) => (React.createElement(DataList.Cell, Object.assign({}, cellProps(column), { style: level > 1 && columnIndex === 0 ? { paddingLeft: (level - 1) * 60 } : undefined }),
+                            level > 0 && columnIndex === 0 && React.createElement(DataList.TreeLine, { isLast: itemIndex === items.length - 1 }),
+                            React.createElement(DataListCell, { column: column, row: item, index: columnIndex, rows: items }))) })),
+                item.items && (React.createElement(WithGroup, { level: level },
+                    React.createElement(Rows, { columns: columns, items: item.items, level: level + 1, 
+                        // We are in last group if we are last item on main level or isLastGroup has been passed from above, meaning we are in a nested group of last item
+                        isLastGroup: (level === 0 && itemIndex === items.length - 1) || isLastGroup })))));
+        } })));
+};
+// rowgroups are not allowed to contain other rowgroups so we will only use this role for first level groups
+const WithGroup = ({ level, children }) => level === 0 ? React.createElement(DataList.Row, { isGroup: true }, children) : children;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/molecules/ItemList/ItemList.spec.d.ts

@@ -0,0 +1,24 @@
+export declare const createService: (type?: string) => () => {
+    id: string;
+    name: string;
+    type: string | undefined;
+};
+export declare const serviceItems: {
+    items: ({
+        id: string;
+        name: string;
+        type: string | undefined;
+    } | {
+        items: {
+            id: string;
+            name: string;
+            type: string | undefined;
+        }[];
+        id: string;
+        name: string;
+        type: string | undefined;
+    })[];
+    id: string;
+    name: string;
+    type: string | undefined;
+}[];

package/dist/src/molecules/ItemList/ItemList.spec.js

@@ -0,0 +1,100 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import React from 'react';
+import { faker } from '@faker-js/faker';
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { ItemList } from './ItemList';
+export const createService = (type) => () => ({
+    id: faker.string.uuid(),
+    name: faker.word.adjective() + ' ' + faker.word.noun(),
+    type,
+});
+function recursiveFlat(items) {
+    const flattenedItems = [];
+    items.forEach((item) => {
+        flattenedItems.push(item);
+        if (Array.isArray(item.items)) {
+            flattenedItems.push(...recursiveFlat(item.items));
+        }
+    });
+    return flattenedItems;
+}
+export const serviceItems = [
+    Object.assign(Object.assign({}, createService('pg')()), { items: faker.helpers.multiple(createService('pg'), { count: 3 }) }),
+    Object.assign(Object.assign({}, createService('kafka')()), { items: faker.helpers.multiple(createService('kafka'), { count: 5 }) }),
+    Object.assign(Object.assign({}, createService('mysql')()), { items: [
+            ...faker.helpers.multiple(createService('mysql'), { count: 2 }),
+            Object.assign(Object.assign({}, createService('mysql')()), { items: faker.helpers.multiple(createService('mysql'), { count: 4 }) }),
+        ] }),
+];
+const getRowContents = () => {
+    const [_header, ...rows] = screen.getAllByRole('row');
+    return rows.map((row) => row.textContent);
+};
+describe('<ItemList />', () => {
+    describe('given recursive list', () => {
+        beforeEach(() => {
+            render(React.createElement(ItemList, { items: serviceItems, columns: [
+                    {
+                        headerName: 'Service',
+                        type: 'text',
+                        field: 'name',
+                    },
+                ] }));
+        });
+        it('should render all items recursively', () => {
+            expect(getRowContents()).toEqual(recursiveFlat(serviceItems).map((item) => item.name));
+        });
+        it('should contain 3 row groups', () => {
+            const rowgroups = screen.getAllByRole('rowgroup');
+            expect(rowgroups).toHaveLength(3);
+        });
+        it('rowgroups should contain their respective rows', () => {
+            const [pg, kafka, mysql] = screen.getAllByRole('rowgroup');
+            expect(within(pg)
+                .getAllByRole('row')
+                .map((node) => node.textContent)).toEqual(serviceItems[0].items.map((item) => item.name));
+            expect(within(kafka)
+                .getAllByRole('row')
+                .map((node) => node.textContent)).toEqual(serviceItems[1].items.map((item) => item.name));
+            expect(within(mysql)
+                .getAllByRole('row')
+                .map((node) => node.textContent)).toEqual(recursiveFlat(serviceItems[2].items).map((item) => item.name));
+        });
+    });
+    describe('given a flat list', () => {
+        const services = faker.helpers.multiple(createService('pg'), { count: 10 });
+        beforeEach(() => {
+            render(React.createElement(ItemList, { items: services, columns: [
+                    {
+                        headerName: 'Service',
+                        type: 'text',
+                        field: 'name',
+                        sort: (a, b) => a.name.localeCompare(b.name),
+                    },
+                ] }));
+        });
+        it('should allow sorting', () => __awaiter(void 0, void 0, void 0, function* () {
+            const user = userEvent.setup();
+            const header = screen.getByRole('button', { name: 'Service' });
+            // Initial state
+            const expected = services.map((item) => item.name);
+            expect(getRowContents()).toEqual(expected);
+            // Sort ascending
+            yield user.click(header);
+            expect(getRowContents()).toEqual([...expected].sort((a, b) => a.localeCompare(b)));
+            // Sort descending
+            yield user.click(header);
+            expect(getRowContents()).toEqual([...expected].sort((a, b) => b.localeCompare(a)));
+        }));
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/molecules/ItemList/types.d.ts

@@ -0,0 +1,114 @@
+import type { Key } from 'react';
+import type { DropdownMenuItemsComponent } from '../../../src/molecules/DropdownMenu/DropdownMenu';
+import type { ChipStatus, TableItem, Weight } from '../../../src/system';
+import type { ActionType } from '../../../types/ActionType';
+export type Item = Record<string, unknown> & {
+    /**
+     * Assigned ID for each data row.
+     * Used as a key. Use something unqiue derived from the data, not index.
+     */
+    id: React.Key;
+    /**
+     * Reserved key for each item, will be used to render sub-items
+     */
+    items?: Item[];
+};
+export type Column = {
+    /**
+     * Type of the column.
+     */
+    type: 'action' | 'custom' | 'item' | 'menu' | 'number' | 'status' | 'text';
+    /**
+     * Display name for the column. Also works as a title for the column. Should be unique.
+     */
+    headerName: string;
+    /**
+     * Determines if the header name should be visible.
+     * Because headerName is used as a key use this to toggle visibility instead of empty string as headerName.
+     */
+    headerInvisible?: boolean;
+};
+type Sortable<R> = {
+    /**
+     * Optional compare function for sorting.
+     */
+    sort?: (a: R, b: R) => number;
+};
+export type TextColumn<R> = Sortable<R> & {
+    /**
+     * Type of the column.
+     */
+    type: 'text';
+};
+export type NumberColumn<R> = Sortable<R> & {
+    /**
+     * Type of the column.
+     */
+    type: 'number';
+};
+export type ActionColumn<R> = Sortable<R> & {
+    /**
+     * Type of the column.
+     */
+    type: 'action';
+    /**
+     * Callback function that resolves to Button props.
+     */
+    action: (row: R, index: number, rows: R[] | undefined) => ActionType;
+};
+export type MenuColumn<R> = {
+    /**
+     * Type of the column.
+     */
+    type: 'menu';
+    /**
+     * Menu items definition. Can be same or unique for each row. No menu will be rendered if undefined is returned.
+     */
+    menu: (row: R, index: number) => DropdownMenuItemsComponent | undefined;
+    /**
+     * Called when an item from the menu is selected.
+     */
+    onAction: (action: Key, row: R, index: number) => void;
+};
+type ItemColumn<R> = Sortable<R> & {
+    /**
+     * Type of the column.
+     */
+    type: 'item';
+    /**
+     * Callback function that resolves to TableItem props
+     */
+    item: (row: R, index: number, rows: R[] | undefined) => TableItem | undefined;
+};
+export type TableStatus = {
+    status: ChipStatus;
+    text: number | string;
+};
+type StatusColumn<R> = Sortable<R> & {
+    /**
+     * Type of the column.
+     */
+    type: 'status';
+    /**
+     * Callback function that resolves to StatusChip props
+     */
+    status: (row: R, index: number, rows: R[] | undefined) => TableStatus | undefined;
+};
+export type CustomColumn<R> = Sortable<R> & {
+    /**
+     * Type of the column.
+     */
+    type: 'custom';
+    /**
+     * Custom render function if no other column type suits your needs.
+     */
+    render: (row: R, index: number, rows: R[] | undefined) => React.ReactNode;
+};
+export type WeightColumn = {
+    /**
+     * Width of the column. Number for pixels and string for percentages
+     */
+    width?: Weight | number;
+};
+export type ListColumn<I extends Item> = Column & WeightColumn & (ActionColumn<I> | CustomColumn<I> | ItemColumn<I> | MenuColumn<I> | NumberColumn<I> | StatusColumn<I> | TextColumn<I>);
+export {};

package/dist/src/molecules/ItemList/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbW9sZWN1bGVzL0l0ZW1MaXN0L3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/src/molecules/PageHeader/PageHeader.d.ts

@@ -32,11 +32,11 @@ export type PageHeaderProps = CommonPageHeaderProps & {
     imageAlt?: string;
     /**
      * Optional secondary actions. There can be one or more secondary actions in the header.
-     * The number of secondary actions is not restricted.
+     * The max number of secondary actions is 2.
      * This can either be a callback function or a link.
-     * @deprecated Use "secondaryAction" and/or "menu" props instead if there are more than 1 secondary actions.
+     * Use "menu" props instead if there are more than 2 secondary actions.
      */
-    secondaryActions?: Array<AsyncActionType | LinkActionType> | AsyncActionType | LinkActionType;
+    secondaryActions?: AsyncActionType | LinkActionType | [AsyncActionType | LinkActionType, AsyncActionType | LinkActionType] | [AsyncActionType | LinkActionType];
     /**
      * Optional list of chips, which will be rendered as chips underneath the page title.
      */

package/dist/src/molecules/PageHeader/PageHeader.js

@@ -13,6 +13,10 @@ import { defaultContextualMenuPlacement } from '../../../types/ContextualMenu';
 import more from '../../../src/icons/more';
 const CommonPageHeader = ({ title, subtitle, image, imageAlt, primaryAction, secondaryAction, secondaryActions = secondaryAction ? [secondaryAction] : undefined, chips = [], breadcrumbs, menu, menuLabel, menuAriaLabel = menuLabel !== null && menuLabel !== void 0 ? menuLabel : 'Context menu', onAction, onMenuOpenChange, isSubHeader = false, }) => {
     var _a, _b;
+    const actions = [primaryAction, ...castArray(secondaryActions)].filter(Boolean);
+    if (actions.length > 2) {
+        throw new Error('Limit the combined `primaryAction` and `secondaryActions` to 2 actions. Use the `menu` prop for additional actions.');
+    }
     return (React.createElement(BasePageHeader, { className: "Aquarium-PageHeader" },
         React.createElement(BasePageHeader.Container, null,
             breadcrumbs && (React.createElement(Box, { marginBottom: "3" },
@@ -40,4 +44,4 @@ PageHeader.displayName = 'PageHeader';
 const SubHeader = (props) => React.createElement(CommonPageHeader, Object.assign({}, props, { isSubHeader: true }));
 PageHeader.SubHeader = SubHeader;
 PageHeader.SubHeader.displayName = 'PageHeader.SubHeader';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/molecules/index.d.ts

@@ -71,10 +71,13 @@ export * from './TimePicker/TimePicker';
 export * from './Toast/Toast';
 export * from './Tooltip/Tooltip';
 export * from './Typography/Typography';
+export * from '../utils/table/sortByColumn';
 export * from '../utils/table/types';
 export * from '../utils/table/useScrollTarget';
+export * from '../utils/table/useSortState';
 export * from '../utils/table/useTableSelect';
 export * from '../utils/table/useTableSort';
+export * from './ItemList/ItemList';
 export * from './Pagination/usePagination';
 export declare const SelectItem: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLLIElement> & {
     key: string;

package/dist/src/molecules/index.js

@@ -74,10 +74,13 @@ export * from './Toast/Toast';
 export * from './Tooltip/Tooltip';
 export * from './Typography/Typography';
 // Exported atoms and utility functions
+export * from '../utils/table/sortByColumn';
 export * from '../utils/table/types';
 export * from '../utils/table/useScrollTarget';
+export * from '../utils/table/useSortState';
 export * from '../utils/table/useTableSelect';
 export * from '../utils/table/useTableSort';
+export * from './ItemList/ItemList';
 export * from './Pagination/usePagination';
 export const SelectItem = Select.Item;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/utils/table/sortByColumn.d.ts

@@ -0,0 +1,3 @@
+import { type Columns, type Item } from '../../../src/molecules';
+import type { SortState } from './useSortState';
+export declare const sortByColumn: <I extends Item>(items: I[], column: Columns<I>, sortState: SortState) => I[];

package/dist/src/utils/table/sortByColumn.js

@@ -0,0 +1,23 @@
+import { columnHasSort } from '../../../src/molecules';
+export const sortByColumn = (items, column, sortState) => {
+    const sortedColumn = column.find((column) => column.headerName === (sortState === null || sortState === void 0 ? void 0 : sortState.headerName));
+    if (sortState && sortedColumn && columnHasSort(sortedColumn)) {
+        const sortFunction = sortedColumn.sort;
+        if (sortFunction) {
+            const ascending = [...items].sort((a, b) => sortFunction(a, b, sortState.direction));
+            if (sortState.direction === 'descending') {
+                return ascending.reverse();
+            }
+            else {
+                return ascending;
+            }
+        }
+        // Sort function not in column definition, this should never be reached
+        return items;
+    }
+    else {
+        // sortState is undefined or we did not find a sortable column
+        return items;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydEJ5Q29sdW1uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL3RhYmxlL3NvcnRCeUNvbHVtbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUEyQixNQUFNLGVBQWUsQ0FBQztBQUl2RSxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FBaUIsS0FBVSxFQUFFLE1BQWtCLEVBQUUsU0FBb0IsRUFBRSxFQUFFO0lBQ25HLE1BQU0sWUFBWSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxVQUFVLE1BQUssU0FBUyxhQUFULFNBQVMsdUJBQVQsU0FBUyxDQUFFLFVBQVUsQ0FBQSxDQUFDLENBQUM7SUFDMUYsSUFBSSxTQUFTLElBQUksWUFBWSxJQUFJLGFBQWEsQ0FBQyxZQUFZLENBQUMsRUFBRSxDQUFDO1FBQzdELE1BQU0sWUFBWSxHQUFHLFlBQVksQ0FBQyxJQUFJLENBQUM7UUFDdkMsSUFBSSxZQUFZLEVBQUUsQ0FBQztZQUNqQixNQUFNLFNBQVMsR0FBRyxDQUFDLEdBQUcsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsWUFBWSxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsU0FBUyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7WUFDckYsSUFBSSxTQUFTLENBQUMsU0FBUyxLQUFLLFlBQVksRUFBRSxDQUFDO2dCQUN6QyxPQUFPLFNBQVMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUM3QixDQUFDO2lCQUFNLENBQUM7Z0JBQ04sT0FBTyxTQUFTLENBQUM7WUFDbkIsQ0FBQztRQUNILENBQUM7UUFDRCx1RUFBdUU7UUFDdkUsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO1NBQU0sQ0FBQztRQUNOLDhEQUE4RDtRQUM5RCxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7QUFDSCxDQUFDLENBQUMifQ==

package/dist/src/utils/table/types.d.ts

@@ -14,7 +14,7 @@ export type Column = {
     /**
      * Type of the column.
      */
-    type: 'action' | 'custom' | 'item' | 'number' | 'status' | 'text';
+    type: 'action' | 'custom' | 'item' | 'menu' | 'number' | 'status' | 'text';
     /**
      * Display name for the column.
      */
@@ -88,6 +88,20 @@ export type ActionColumn<R> = CustomSortable<R> & {
      */
     action: (row: R, index: number, rows: R[] | undefined) => ActionType;
 };
+export type MenuColumn<R> = {
+    /**
+     * Type of the column.
+     */
+    type: 'menu';
+    /**
+     * Menu items definition. Can be same or unique for each row. No menu will be rendered if undefined is returned.
+     */
+    menu: (row: R, index: number) => DropdownMenuItemsComponent | undefined;
+    /**
+     * Called when an item from the menu is selected.
+     */
+    onAction: (action: Key, row: R, index: number) => void;
+};
 export type CustomColumn<R> = CustomSortable<R> & {
     /**
      * Type of the column.
@@ -130,7 +144,7 @@ type StatusColumn<R> = Column & CustomSortable<R> & {
      */
     status: (row: R, index: number, rows: R[] | undefined) => TableStatus | undefined;
 };
-type ListColumn = Column & {
+export type WeightColumn = Column & {
     /**
      * Width of the column. Number for pixels and string for percentages
      */
@@ -142,7 +156,11 @@ type TableColumn = Column & {
      */
     width?: number | `${number}%`;
 };
-export type DataListColumn<R extends DataTableRow> = DataColumn<R, ListColumn>;
+export type MenuColumnType<R extends DataTableRow> = Column & ColumnBase<R> & MenuColumn<R> & {
+    width?: 'auto';
+};
+export type ItemListColumn<R extends DataTableRow> = DataColumn<R, WeightColumn> | MenuColumnType<R>;
+export type DataListColumn<R extends DataTableRow> = DataColumn<R, WeightColumn>;
 export type DataTableColumn<R extends DataTableRow> = DataColumn<R, TableColumn>;
 type DataColumn<R extends DataTableRow, C extends Column> = C & ColumnBase<R> & (ActionColumn<R> | CustomColumn<R> | ItemColumn<R> | NumberColumn<R> | StatusColumn<R> | TextColumn<R>);
 export type DataTableRowId = number | string;
@@ -169,6 +187,8 @@ type CellProps = {
     stickyColumn?: StickyColumn;
 };
 export declare const cellProps: <C extends Column>(column: C) => CellProps;
+type SortableColumn<R extends DataTableRow> = ActionColumn<R> | CustomColumn<R> | FieldColumn<R> | ItemColumn<R> | NumberColumn<R> | StatusColumn<R> | TextColumn<R>;
+export declare const columnHasSort: <R extends DataTableRow>(column: DataColumn<R, any>) => column is SortableColumn<R>;
 export declare const columnIsFieldColumn: <R extends DataTableRow>(column?: DataColumn<R, any>) => column is FieldColumn<R>;
 export type DataTableMenuProps<R extends DataTableRow> = AllOrNone<Omit<CommonContextualMenuProps, 'menu' | 'onAction'> & {
     /**

package/dist/src/utils/table/types.js

@@ -8,6 +8,7 @@ export const cellProps = (column) => {
     var _a;
     let align;
     switch (column.type) {
+        case 'menu':
         case 'action':
         case 'number': {
             align = 'right';
@@ -27,8 +28,9 @@ export const cellProps = (column) => {
         stickyColumn: column.sticky,
     };
 };
+export const columnHasSort = (column) => (columnIsFieldColumn(column) && column.sortable) || Boolean(column.sort);
 export const columnIsFieldColumn = (column) => Boolean(column && column.field);
 export function isOnSortChangedDirection(value) {
     return value === undefined || ['ascending', 'descending'].includes(value);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvdGFibGUvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEseUNBQXlDO0FBQ3pDLE9BQU8sT0FBTyxNQUFNLGdCQUFnQixDQUFDO0FBd01yQyxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsQ0FDNUIsSUFBa0MsRUFDRixFQUFFO0lBQ2xDLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDeEIsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLENBQUMsU0FBb0MsRUFBMEIsRUFBRSxDQUM5RixTQUFTLEtBQUssV0FBVyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLFNBQVMsS0FBSyxZQUFZLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDO0FBVWxGLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFtQixNQUFTLEVBQWEsRUFBRTs7SUFDbEUsSUFBSSxLQUE0QixDQUFDO0lBRWpDLFFBQVEsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3BCLEtBQUssUUFBUSxDQUFDO1FBQ2QsS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDO1lBQ2QsS0FBSyxHQUFHLE9BQU8sQ0FBQztZQUNoQixNQUFNO1FBQ1IsQ0FBQztRQUVELEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQztZQUNkLEtBQUssR0FBRyxTQUFTLENBQUM7WUFDbEIsTUFBTTtRQUNSLENBQUM7UUFFRCxPQUFPLENBQUMsQ0FBQyxDQUFDO1lBQ1IsS0FBSyxHQUFHLE1BQU0sQ0FBQztRQUNqQixDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU87UUFDTCxHQUFHLEVBQUUsTUFBQSxNQUFNLENBQUMsR0FBRyxtQ0FBSSxNQUFNLENBQUMsVUFBVTtRQUNwQyxLQUFLO1FBQ0wsWUFBWSxFQUFFLE1BQU0sQ0FBQyxNQUFNO0tBQzVCLENBQUM7QUFDSixDQUFDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxDQUF5QixNQUEyQixFQUE0QixFQUFFLENBQ25ILE9BQU8sQ0FBQyxNQUFNLElBQUssTUFBeUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQTJCdEQsTUFBTSxVQUFVLHdCQUF3QixDQUFDLEtBQXlCO0lBQ2hFLE9BQU8sS0FBSyxLQUFLLFNBQVMsSUFBSSxDQUFDLFdBQVcsRUFBRSxZQUFZLENBQUMsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDNUUsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvdGFibGUvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEseUNBQXlDO0FBRXpDLE9BQU8sT0FBTyxNQUFNLGdCQUFnQixDQUFDO0FBNE5yQyxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsQ0FDNUIsSUFBa0MsRUFDRixFQUFFO0lBQ2xDLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDeEIsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLENBQUMsU0FBb0MsRUFBMEIsRUFBRSxDQUM5RixTQUFTLEtBQUssV0FBVyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLFNBQVMsS0FBSyxZQUFZLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDO0FBVWxGLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFtQixNQUFTLEVBQWEsRUFBRTs7SUFDbEUsSUFBSSxLQUE0QixDQUFDO0lBRWpDLFFBQVEsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3BCLEtBQUssTUFBTSxDQUFDO1FBQ1osS0FBSyxRQUFRLENBQUM7UUFDZCxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUM7WUFDZCxLQUFLLEdBQUcsT0FBTyxDQUFDO1lBQ2hCLE1BQU07UUFDUixDQUFDO1FBRUQsS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDO1lBQ2QsS0FBSyxHQUFHLFNBQVMsQ0FBQztZQUNsQixNQUFNO1FBQ1IsQ0FBQztRQUVELE9BQU8sQ0FBQyxDQUFDLENBQUM7WUFDUixLQUFLLEdBQUcsTUFBTSxDQUFDO1FBQ2pCLENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTztRQUNMLEdBQUcsRUFBRSxNQUFBLE1BQU0sQ0FBQyxHQUFHLG1DQUFJLE1BQU0sQ0FBQyxVQUFVO1FBQ3BDLEtBQUs7UUFDTCxZQUFZLEVBQUUsTUFBTSxDQUFDLE1BQU07S0FDNUIsQ0FBQztBQUNKLENBQUMsQ0FBQztBQVdGLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxDQUF5QixNQUEwQixFQUErQixFQUFFLENBQy9HLENBQUMsbUJBQW1CLENBQUMsTUFBTSxDQUFDLElBQUksTUFBTSxDQUFDLFFBQVEsQ0FBQyxJQUFJLE9BQU8sQ0FBRSxNQUE0QixDQUFDLElBQUksQ0FBQyxDQUFDO0FBRWxHLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLENBQXlCLE1BQTJCLEVBQTRCLEVBQUUsQ0FDbkgsT0FBTyxDQUFDLE1BQU0sSUFBSyxNQUF5QixDQUFDLEtBQUssQ0FBQyxDQUFDO0FBMkJ0RCxNQUFNLFVBQVUsd0JBQXdCLENBQUMsS0FBeUI7SUFDaEUsT0FBTyxLQUFLLEtBQUssU0FBUyxJQUFJLENBQUMsV0FBVyxFQUFFLFlBQVksQ0FBQyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUM1RSxDQUFDIn0=

package/dist/src/utils/table/useSortState.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { SortDirection } from '../../../src/utils/table/types';
+type Direction = Extract<SortDirection, 'ascending' | 'descending'>;
+export type SortState = {
+    headerName: string;
+    direction: Direction;
+} | undefined;
+export declare const useSortState: (initialSortState?: SortState) => [{
+    headerName: string;
+    direction: Direction;
+} | undefined, React.Dispatch<React.SetStateAction<{
+    headerName: string;
+    direction: Direction;
+} | undefined>>];
+export {};

package/dist/src/utils/table/useSortState.js

@@ -0,0 +1,3 @@
+import React from 'react';
+export const useSortState = (initialSortState) => React.useState(initialSortState);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlU29ydFN0YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL3RhYmxlL3VzZVNvcnRTdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssTUFBTSxPQUFPLENBQUM7QUFPMUIsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsZ0JBQTRCLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyJ9

package/dist/src/utils/table/useTableSort.d.ts

@@ -1,11 +1,11 @@
-import { type DataListColumn, type DataTableColumn, type DataTableRow, type OnSortChangedDirection, type Sort } from '../../../src/utils/table/types';
+import { type DataListColumn, type DataTableColumn, type DataTableRow, type ItemListColumn, type OnSortChangedDirection, type Sort } from '../../../src/utils/table/types';
 import type { AllOrNone } from '../../../types/utils';
 type OnSortChangedCallback = (args: {
     key: string | undefined;
     direction: OnSortChangedDirection;
 } | null) => void;
-type UseTableSortOptions<C extends DataListColumn<R> | DataTableColumn<R>, R extends DataTableRow> = AllOrNone<Sort<C>> & {
+type UseTableSortOptions<C extends DataListColumn<R> | DataTableColumn<R> | ItemListColumn<R>, R extends DataTableRow> = AllOrNone<Sort<C>> & {
     onSortChanged?: OnSortChangedCallback;
 };
-export declare const useTableSort: <C extends DataListColumn<R> | DataTableColumn<R>, R extends DataTableRow>({ column, direction, onSortChanged, }?: UseTableSortOptions<C, R>) => [Sort<C> | undefined, (column: C) => void];
+export declare const useTableSort: <C extends DataListColumn<R> | DataTableColumn<R> | ItemListColumn<R>, R extends DataTableRow>({ column, direction, onSortChanged }?: UseTableSortOptions<C, R>) => [Sort<C> | undefined, (column: C) => void];
 export {};