@mailstep/design-system 0.4.21 → 0.5.0

package/ui/Blocks/CommonGrid/storybook/utils/columnDefinition.js

@@ -0,0 +1,97 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+export var oversizedArrayColumns = 25;
+export var enumValues = ['option A', 'option B', 'option C'];
+var ComplexCell = function (props) {
+    var handleActionClick = React.useCallback(function () {
+        if (props.onRowAction)
+            props.onRowAction(props.rowData.id, 'get_invoice', null);
+        //     // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [props.rowData, props.onRowAction]);
+    return _jsxs("button", { onClick: handleActionClick, children: [" download ", props.rowData.id, " "] });
+};
+export var oversizedColumnDefinition = new Array(oversizedArrayColumns).fill(null).map(function (unused, index) { return ({
+    name: "column_".concat(index),
+    title: "column_".concat(index),
+    flexBasis: 120,
+}); });
+export var enumColumn = {
+    name: 'enumColumn',
+    title: 'Enum Column',
+    flexBasis: 160,
+    filterOptions: __spreadArray([{ value: '', label: 'all' }], enumValues.map(function (v) { return ({ value: v, label: v }); }), true),
+    filtering: true,
+    sorting: false,
+};
+export var columnDefinitions = [
+    {
+        name: 'textColumn',
+        title: 'Text column',
+        flexBasis: 160,
+        filtering: true,
+        sorting: true,
+    },
+    enumColumn,
+    {
+        name: 'numberColumn',
+        title: 'Number Column',
+        flexBasis: 160,
+        filtering: true,
+        filteringType: 'number',
+        sorting: true,
+    },
+    {
+        name: 'dateColumn',
+        group: 'group1',
+        title: 'Date Column',
+        flexBasis: 160,
+        filtering: true,
+        filteringType: 'date',
+        sorting: true,
+    },
+    {
+        name: 'boolColumn',
+        group: 'group1',
+        title: 'Bool Column',
+        flexBasis: 160,
+        filtering: true,
+        filteringType: 'flag',
+        sorting: true,
+        formatRowValue: function (row) {
+            return row.boolColumn ? 'Yes' : 'No';
+        },
+    },
+    {
+        name: 'advancedColumn',
+        group: 'group2',
+        title: 'Advanced Column',
+        flexBasis: 160,
+        formatRowValue: function (row) {
+            return "".concat((row.numberColumn / 4) * row.textColumn.length);
+        },
+    },
+    {
+        name: 'complexColumn',
+        group: 'group2',
+        title: 'Complex Column',
+        flexBasis: 350,
+        cellComponent: ComplexCell,
+    },
+    {
+        name: 'stickyColumn',
+        title: 'Sticky Column',
+        flexBasis: 160,
+        alwaysOn: true,
+        sticky: true,
+        stickTo: 'right',
+    },
+];

package/ui/Blocks/CommonGrid/storybook/utils/filters.d.ts

@@ -0,0 +1,2 @@
+import { FiltersConfig } from '../../types';
+export declare const filters: FiltersConfig;

package/ui/Blocks/CommonGrid/storybook/utils/filters.js

@@ -0,0 +1,23 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+var DefaultSelect = function (props) { return (_jsx("select", __assign({ multiple: props.isMulti }, props, { children: (props.options || []).map(function (_a) {
+        var value = _a.value, label = _a.label;
+        return (_jsx("option", { value: value, children: label }, value));
+    }) }))); };
+export var filters = {
+    options: { CellComponent: DefaultSelect },
+    number: { CellComponent: function () { return _jsx("input", { type: "number" }); } },
+    text: { CellComponent: function () { return _jsx("input", { type: "text" }); } },
+    date: { CellComponent: function () { return _jsx("input", { type: "date" }); } },
+    flag: { CellComponent: function () { return _jsx("input", { type: "text" }); } },
+};

package/ui/Blocks/CommonGrid/storybook/utils/utils.d.ts

@@ -0,0 +1,17 @@
+import { GridActionsType, rowClassSymbol } from '../../types';
+export declare const enumValues: string[];
+export declare const oversizedArrayColumns = 25;
+export declare const gridSelectors: {};
+export declare const createRandomData: (count: number) => {
+    id: string;
+    stickyColumn: string;
+    textColumn: string;
+    enumColumn: string;
+    numberColumn: number;
+    dateColumn: string;
+    boolColumn: boolean;
+    [rowClassSymbol]: string | undefined;
+}[];
+export declare const gridDummyActions: Required<GridActionsType>;
+export declare const createOversizedRandomData: (count: number) => any[];
+export declare const ReduxGrid: (props: any) => JSX.Element;

package/ui/Blocks/CommonGrid/storybook/utils/utils.js

@@ -0,0 +1,66 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import faker from 'faker';
+import { rowClassSymbol } from '../../types';
+import withReduxActions from '../../HoC/withReduxActions';
+import CommonGrid from '../../CommonGrid';
+export var enumValues = ['option A', 'option B', 'option C'];
+export var oversizedArrayColumns = 25;
+export var gridSelectors = {};
+/**
+ * randomly returns given data or undefined. used to simulate optional pros on object data types
+ */
+function makeOptional(fakerData, chance) {
+    chance = chance || 0.5;
+    return Math.random() < chance ? fakerData : undefined;
+}
+export var createRandomData = function (count) {
+    return new Array(count).fill(null).map(function () {
+        var _a;
+        return (_a = {
+                id: faker.random.uuid(),
+                stickyColumn: faker.random.word(),
+                textColumn: faker.random.word(),
+                enumColumn: enumValues[faker.random.number({ min: 0, max: 2 })],
+                numberColumn: faker.random.number(),
+                dateColumn: faker.date.recent().toISOString(),
+                boolColumn: faker.random.boolean()
+            },
+            _a[rowClassSymbol] = makeOptional('foo'),
+            _a);
+    });
+};
+export var gridDummyActions = {
+    // @see types for full list of actions
+    setPage: function (number) { return console.log('setPage', number); },
+    setRowsPerPage: function (number) { return console.log('setRowsPerPage', number); },
+    addFilter: function (column, value, filterProps) {
+        return console.log('setRowsPerPage', column, value, filterProps);
+    },
+};
+export var createOversizedRandomData = function (count) {
+    return new Array(count).fill(null).map(function () {
+        var newData = {
+            id: "".concat(faker.random.uuid()),
+        };
+        for (var index = 0; index < oversizedArrayColumns; index++) {
+            newData["column_".concat(index)] = faker.name.lastName();
+        }
+        return newData;
+    });
+};
+export var ReduxGrid = function (props) {
+    var WithActions = React.useMemo(function () { return withReduxActions('storybookGrid')(CommonGrid); }, []);
+    return _jsx(WithActions, __assign({}, props));
+};

package/ui/Blocks/CommonGrid/storybook/utils/withRedux.d.ts

@@ -0,0 +1,2 @@
+export declare const withProvider: (story: Function) => JSX.Element;
+export default withProvider;

package/ui/Blocks/CommonGrid/storybook/utils/withRedux.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Provider } from 'react-redux';
+import { combineReducers, createStore } from 'redux';
+import commonGridReducer from '../../store';
+export var withProvider = function (story) {
+    var reducers = combineReducers({
+        commonGrid: commonGridReducer,
+    });
+    var store = createStore(reducers);
+    return _jsx(Provider, { store: store, children: story() });
+};
+export default withProvider;

package/ui/Blocks/CommonGrid/storybook/utils/withRouter.d.ts

@@ -0,0 +1,2 @@
+declare const withProvider: (story: Function) => JSX.Element;
+export default withProvider;

package/ui/Blocks/CommonGrid/storybook/utils/withRouter.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { MemoryRouter } from 'react-router';
+var withProvider = function (story) { return _jsx(MemoryRouter, { children: story() }); };
+export default withProvider;

package/ui/Blocks/CommonGrid/storybook/utils/withTheme.d.ts

@@ -0,0 +1,2 @@
+declare const withProvider: (story: Function) => JSX.Element;
+export default withProvider;

package/ui/Blocks/CommonGrid/storybook/utils/withTheme.js

@@ -0,0 +1,18 @@
+/*
+import React from 'react'
+import Theme from '@designSystem/Theme'
+import Normalize, { NormalizeBaseFonts } from '@designSystem/Normalize'
+
+const withProvider = (story: Function): JSX.Element => (
+  <Theme>
+    <Normalize />
+    <NormalizeBaseFonts />
+    {story()}
+  </Theme>
+)
+
+export default withProvider
+*/
+// @TODO do theme
+var withProvider = function (story) { return (story()); };
+export default withProvider;

package/ui/Blocks/CommonGrid/types.d.ts

@@ -0,0 +1,299 @@
+import React from 'react';
+export declare const rowClassSymbol: unique symbol;
+type Option = {
+    value: string | number;
+    label: string | number;
+};
+type TranslatorPublicInterfaceProps = {
+    id?: string;
+    defaults?: string;
+};
+type ButtonPublicInterfaceProps = {
+    children?: React.ReactNode;
+    type?: 'button' | 'submit' | 'reset';
+    appearance?: string;
+    isLoading?: boolean;
+    disabled?: boolean;
+    margin?: string;
+    className?: string;
+    onClick?: (arg?: any) => void;
+};
+type CheckboxPublicInterfaceProps = {
+    name?: string;
+    label?: string | JSX.Element;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    checked?: boolean;
+};
+type SwitchPublicInterfaceProps = {
+    onChange?: (event: React.ChangeEvent) => void;
+    label?: string;
+    name: string;
+    checked?: boolean;
+};
+export type PaginatorProps = {
+    page: number;
+    itemCount: number;
+    itemPerPage: number;
+    onPageChange: (number: number) => void;
+};
+export type FilterComponentProps<VT> = {
+    name: string;
+    onChange: (value: VT | {
+        event: {
+            target: VT;
+        };
+    } | null) => void;
+    value: VT | null;
+    OverlayComponent: React.FunctionComponent;
+};
+export type ColumnTitleComponentType = React.ComponentType<{
+    title?: string | JSX.Element;
+    isSortable: boolean;
+    onSetSort: (value: SortingValueType) => void;
+    sortValue: SortingValueType;
+}>;
+export type ComponentsProps = {
+    Translator: React.ComponentType<TranslatorPublicInterfaceProps>;
+    Checkbox: React.ComponentType<CheckboxPublicInterfaceProps>;
+    Button: React.ComponentType<ButtonPublicInterfaceProps>;
+    Switch: React.ComponentType<SwitchPublicInterfaceProps>;
+    Paginator: React.ComponentType<PaginatorProps>;
+    ColumnTitle?: ColumnTitleComponentType;
+};
+export type FiltersConfig = {
+    [name: string]: {
+        CellComponent: React.ComponentType<FilterComponentProps<any>>;
+        defaultExtraProps?: {
+            [name: string]: any;
+        };
+    };
+};
+type Filtering = {
+    [column: string]: {
+        value: any;
+        filterProps: FilterProps;
+    };
+};
+type Sorting = {
+    column: string;
+    direction: SortingValueType;
+}[];
+export type Settings = {
+    filter: Filtering;
+    sorting: Sorting;
+    offset: number;
+    limit: number;
+};
+export interface SelectMenuItem {
+    label: string;
+    value: string | number;
+    labelInList?: string;
+    disabled?: boolean;
+}
+export type RowProps = {
+    id: string;
+    [rowClassSymbol]?: string;
+};
+type ColumnBaseProps = {
+    flexBasis: number;
+};
+export type RowValueType = string | JSX.Element | number | void;
+export type ColumnDefinition<ColumnName extends string = string> = ColumnBaseProps & {
+    name: ColumnName;
+    group?: Group['name'];
+    systemName?: string;
+    systemFilter?: string;
+    title?: string | JSX.Element;
+    filtering?: boolean;
+    filteringType?: 'number' | 'text' | 'date' | 'flag';
+    disableRowTouch?: boolean;
+    filterExtraProps?: {
+        isMulti?: boolean;
+        comparators?: any;
+        filterTime?: boolean;
+        decimals?: number;
+        isFloat?: boolean;
+        isBigInt?: boolean;
+        isUuid?: boolean;
+        defaultComparator?: string;
+    };
+    getFilterCriteria?: (value: string) => {
+        [column: string]: any;
+    } | null;
+    filterOptions?: Option[];
+    sorting?: boolean;
+    formatRowValue?: (row: any) => RowValueType;
+    cellComponent?: React.ComponentType<DataCellProps<any>>;
+    flexGrow?: number;
+    flexShrink?: number;
+    fixedSize?: boolean;
+    alwaysOn?: boolean;
+    defaultHidden?: boolean;
+    sticky?: boolean;
+    stickTo?: StickTo;
+};
+export type StickTo = 'left' | 'right';
+type batchAction = {
+    value: string;
+    label: string;
+    isEnabled?: (checkedRows: any[]) => boolean;
+};
+export type OnBatchActionFn<T = RowProps> = (action: batchAction, affectedRows: T[]) => void;
+export type ActionColumn = ColumnBaseProps & {
+    actionOptions?: batchAction[];
+    canRowEdit?: boolean | ((row: any) => boolean);
+    canRowRead?: boolean | ((row: any) => boolean);
+    createLink?: (params?: object) => string;
+    forceCheckboxes?: boolean;
+    checkAllPosition?: 'top' | 'bottom';
+    addRowNumbers?: boolean;
+    addRowNumbersLabel?: string;
+};
+export type ActionColumnHeadProps = {
+    actionColumn: ActionColumn;
+    onBatchAction?: OnBatchActionFn;
+    handleUxChange?: GridActionsType['handleUxChange'];
+    rowsData: RowProps[];
+    uxState: UxState;
+};
+export type DataCellProps<T> = {
+    rowData: T;
+    onRowAction?: (id: string, field: string, value: any) => void | Promise<any>;
+    column: ColumnDefinition;
+};
+type SingleColumnConfig = {
+    isHidden?: boolean;
+};
+export type ColumnConfig = {
+    [key: string]: SingleColumnConfig;
+};
+export type SortingValueType = 'asc' | 'desc' | null;
+export type InitProps = {
+    defaultSorting?: Settings['sorting'];
+};
+export type FilterProps = {
+    type: Required<ColumnDefinition>['filteringType'] | 'options';
+    filterExtraProps: ColumnDefinition['filterExtraProps'];
+    computedValue?: any;
+};
+export type UxState = {
+    checkedRows?: {
+        [key: string]: boolean;
+    };
+    selectedRow?: string | null;
+};
+export type ColumnLayout = 'normal' | 'no-scroll' | 'sticky';
+export type GridState = {
+    page: number;
+    rowsPerPage: number;
+    filter: Settings['filter'];
+    sorting: Settings['sorting'];
+    defaultSorting: Settings['sorting'];
+    isConfigFormOpen: boolean;
+    uxState: UxState;
+    columnConfig: ColumnConfig;
+    columnsOrder: string[];
+    columnsWidth: {
+        [anyKey: string]: number;
+    };
+    columnsWidthVariant?: string;
+};
+export type GridSelectorsType = {
+    uxState?: UxState;
+    columnConfig?: ColumnConfig;
+    page?: number;
+    rowsPerPage?: number;
+    filter?: Settings['filter'];
+    sorting?: Settings['sorting'];
+    isConfigFormOpen?: boolean;
+    columnsWidth?: {
+        [anyColumn: string]: number;
+    };
+    columnsWidthVariant?: string;
+    columnsOrder?: string[];
+};
+export type RowsPerPageType = {
+    gridName: string;
+    rowsPerPage: number;
+    type: string;
+};
+export type GridActionsType = {
+    init?: (params?: InitProps) => void;
+    clearUxState?: () => void;
+    handleUxChange?: (uxKey: keyof UxState, uxValue: any) => void;
+    setColumnConfig?: (columnConfig: ColumnConfig) => void | Promise<any>;
+    setPage?: (number: number) => void;
+    setRowsPerPage?: (number: number) => RowsPerPageType | null;
+    addFilter?: (column: string, value: any, filterProps: FilterProps) => void;
+    resetFilters?: () => void;
+    addSorting?: (column: string, direction: SortingValueType) => void;
+    openConfigForm?: () => void;
+    closeConfigForm?: () => void;
+    clearSettings?: () => void;
+    resetGrid?: () => void;
+    setColumnWidth?: (columnsWidth: null | {
+        [anyColumn: string]: number;
+    }, columnLayout: ColumnLayout) => void;
+    setColumnsOrder?: (columnsOrder: string[]) => void;
+};
+export type AsyncFilters = {
+    [anyColumn: string]: Option[];
+};
+export type CommonGridProps<TData extends RowProps = RowProps> = {
+    components?: ComponentsProps;
+    filters?: FiltersConfig;
+    gridSelectors: GridSelectorsType;
+    gridActions: GridActionsType;
+    isLoading?: boolean;
+    rowsData: TData[];
+    hasColouredRows?: boolean;
+    columnsDefinitions: ColumnDefinition[];
+    actionColumnDefinition?: ActionColumn;
+    totalRowsCount?: number;
+    allowRowSelect?: boolean;
+    allowRowSelectOnAction?: boolean;
+    onRowAction?: (id: string, field: string, value: any) => void;
+    onRowEditClick?: (id: string, props: TData) => void;
+    onRowReadClick?: (id: string, props: TData) => void;
+    onRowClick?: (id: string, props: TData) => void;
+    onBatchAction?: OnBatchActionFn;
+    columnLayout?: ColumnLayout;
+    confirmOnReset?: () => boolean;
+    hideColumnConfig?: boolean;
+    hideAllControls?: boolean;
+    className?: string;
+    gridRef?: React.MutableRefObject<HTMLElement>;
+    minColumnWidth?: number;
+    errorMessage?: string;
+    extraControlButtons?: ExtraControlButton[];
+    perPageOptions?: number[];
+    floatingButton?: JSX.Element;
+};
+export declare enum ExtraControlButtonPosition {
+    TopLeft = "top-left",
+    TopRight = "top-right",
+    BottomLeft = "bottom-left",
+    BottomRight = "bottom-right"
+}
+export type ExtraControlButton = {
+    node?: React.ReactNode;
+    onClick?: () => void;
+    onSelect?: (value: string | number) => void;
+    label?: string | JSX.Element;
+    style?: 'primary' | 'secondary';
+    options?: {
+        label: string | JSX.Element;
+        value?: string | number;
+        onClick?: () => void;
+    }[];
+    position?: ExtraControlButtonPosition;
+    hide?: boolean;
+    hideChevron?: boolean;
+    disabled?: boolean;
+};
+export type Group = {
+    name?: string;
+    start: boolean;
+    end: boolean;
+};
+export {};

package/ui/Blocks/CommonGrid/types.js

@@ -0,0 +1,8 @@
+export var rowClassSymbol = Symbol();
+export var ExtraControlButtonPosition;
+(function (ExtraControlButtonPosition) {
+    ExtraControlButtonPosition["TopLeft"] = "top-left";
+    ExtraControlButtonPosition["TopRight"] = "top-right";
+    ExtraControlButtonPosition["BottomLeft"] = "bottom-left";
+    ExtraControlButtonPosition["BottomRight"] = "bottom-right";
+})(ExtraControlButtonPosition || (ExtraControlButtonPosition = {}));

package/ui/Blocks/CommonGrid/utils/index.d.ts

@@ -0,0 +1,17 @@
+import { ColumnDefinition, ActionColumn, ColumnConfig, FilterProps, Group, StickTo } from '../types';
+export declare const getActionCellSizeProps: (column: ActionColumn) => object;
+export declare const getCellSizeProps: (column: ColumnDefinition, columnWidth: number) => object;
+export declare const getSortName: (column: ColumnDefinition) => string;
+export declare const getFilterName: (column: ColumnDefinition) => string;
+export declare const isColumnOn: (column: ColumnDefinition, columnConfig?: ColumnConfig) => boolean;
+export declare const calculatePaginator: (page: number, rowsPerPage: number) => {
+    offset: number;
+    limit: number;
+};
+export declare const createFilterType: (columnDefinition: {
+    filterOptions?: ColumnDefinition['filterOptions'];
+    filteringType?: ColumnDefinition['filteringType'];
+}) => FilterProps['type'];
+export declare const getGroups: (columns: ColumnDefinition[]) => Group[];
+export declare const getGroupClassNames: (group?: Group) => string;
+export declare const getStickyCollClassNames: (sticky: boolean, stickTo?: StickTo) => string;

package/ui/Blocks/CommonGrid/utils/index.js

@@ -0,0 +1,60 @@
+var isDefined = function (val) { return typeof val !== 'undefined'; };
+export var getActionCellSizeProps = function (column) {
+    return {
+        flexBasis: column.flexBasis,
+        flexGrow: 0,
+        flexShrink: 0,
+    };
+};
+export var getCellSizeProps = function (column, columnWidth) {
+    if (!column)
+        return {};
+    var fixedSize = column.fixedSize, flexGrow = column.flexGrow, flexShrink = column.flexShrink, sticky = column.sticky;
+    return {
+        flexBasis: columnWidth,
+        flexGrow: fixedSize ? 0 : isDefined(flexGrow) ? flexGrow : 1,
+        flexShrink: isDefined(flexShrink) ? flexShrink : 1,
+        maxWidth: sticky ? columnWidth : 'auto',
+    };
+};
+export var getSortName = function (column) {
+    return column.systemName || column.name;
+};
+export var getFilterName = function (column) {
+    return column.systemFilter || column.systemName || column.name;
+};
+export var isColumnOn = function (column, columnConfig) {
+    var _a;
+    if (column.alwaysOn)
+        return true;
+    var isHidden = (_a = columnConfig === null || columnConfig === void 0 ? void 0 : columnConfig[column.name]) === null || _a === void 0 ? void 0 : _a.isHidden;
+    if (typeof isHidden === 'boolean')
+        return !isHidden; // isHidden is defined/stored => use user value
+    return !column.defaultHidden; // isHidden is undefined => use default value
+};
+export var calculatePaginator = function (page, rowsPerPage) { return ({
+    offset: rowsPerPage ? rowsPerPage * (page - 1) : rowsPerPage,
+    limit: rowsPerPage,
+}); };
+export var createFilterType = function (columnDefinition) {
+    if (columnDefinition.filterOptions)
+        return 'options';
+    else
+        return columnDefinition.filteringType || 'text';
+};
+export var getGroups = function (columns) {
+    return columns.map(function (column, key) {
+        var previousGroup = key > 0 && columns[key - 1].group;
+        return {
+            name: column.group,
+            start: !!(column.group && (!previousGroup || (previousGroup && previousGroup !== column.group))),
+            end: !!(column.group && (!columns[key + 1] || columns[key + 1].group !== column.group)),
+        };
+    });
+};
+export var getGroupClassNames = function (group) {
+    return "".concat((group === null || group === void 0 ? void 0 : group.start) ? 'group-start' : '', " ").concat((group === null || group === void 0 ? void 0 : group.end) ? 'group-end' : '');
+};
+export var getStickyCollClassNames = function (sticky, stickTo) {
+    return !sticky ? '' : "".concat(stickTo ? " sticky sticky-".concat(stickTo) : ' sticky sticky-left');
+};

package/ui/Blocks/CommonGrid/utils/public.d.ts

@@ -0,0 +1,16 @@
+import { RowProps, GridActionsType, ColumnDefinition, UxState, ActionColumn, OnBatchActionFn } from '../types';
+/**
+ * hook for checkbox that select and unselects all row
+ * returns [checked state, toggleAllHandler()] for checkbox
+ */
+type ToggleAllCheckboxRet = [boolean, () => void];
+export declare const useToggleAllCheckbox: (rowsData: RowProps[], uxState: UxState, handleUxChange?: GridActionsType['handleUxChange']) => ToggleAllCheckboxRet;
+/**
+ * hook for action selection and trigger
+ * returns [subset of actions that are enabled, onSelect(value) - param1: selected action value]
+ */
+type GridActionTriggerRet = [Required<ActionColumn>['actionOptions'], (value: any) => void];
+export declare const useGridActionTrigger: (rowsData: RowProps[], uxState: UxState, actionOptions?: ActionColumn['actionOptions'], onBatchAction?: OnBatchActionFn) => GridActionTriggerRet;
+type AddFilterRet = (value: any, column: ColumnDefinition) => void;
+export declare const useAddFilter: (onChange: Required<GridActionsType>['addFilter']) => AddFilterRet;
+export {};