@mailstep/design-system 0.8.26 → 0.8.27

package/ui/Blocks/CommonGrid/hooks/useCreatePreset.js

@@ -0,0 +1,80 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import { useCallback, useState } from "react";
+import { useModal } from "../../Modal/hooks/useModal";
+import isEmpty from "lodash/isEmpty";
+import { useEvent } from "./useEvent";
+var useCreatePreset = function useCreatePreset(param) {
+    var gridName = param.gridName, filters = param.filters, onClosePresetsModal = param.onClosePresetsModal, setSelectedPresetName = param.setSelectedPresetName, gridActions = param.gridActions;
+    var _useModal = useModal(), isCreatePresetModalOpen = _useModal.isOpen, onOpenCreatePresetModal = _useModal.onOpen, onCloseCreatePresetModal = _useModal.onClose;
+    var _useState = _sliced_to_array(useState(""), 2), presetName = _useState[0], setPresetName = _useState[1];
+    var handleChangePresetName = useCallback(function(event) {
+        setPresetName(event.target.value);
+    }, []);
+    var handleCloseCreatePresetModal = useCallback(function() {
+        setPresetName("");
+        onCloseCreatePresetModal();
+    }, []);
+    var handleCreatePreset = useEvent(function() {
+        var _gridActions_createPreset;
+        setPresetName("");
+        onCloseCreatePresetModal();
+        onClosePresetsModal();
+        if (isEmpty(filters) || !gridName) return;
+        (_gridActions_createPreset = gridActions.createPreset) === null || _gridActions_createPreset === void 0 ? void 0 : _gridActions_createPreset.call(gridActions, presetName, filters);
+        setSelectedPresetName(presetName);
+    });
+    return {
+        isCreatePresetModalOpen: isCreatePresetModalOpen,
+        onOpenCreatePresetModal: onOpenCreatePresetModal,
+        handleCloseCreatePresetModal: handleCloseCreatePresetModal,
+        presetName: presetName,
+        handleChangePresetName: handleChangePresetName,
+        handleCreatePreset: handleCreatePreset
+    };
+};
+export { useCreatePreset };

package/ui/Blocks/CommonGrid/hooks/useDeletePreset.d.ts

@@ -1,6 +1,5 @@
 import { MouseEvent } from 'react';
 import { GridActionsType } from '../types';
-
 type Props = {
     gridName?: string;
     selectedPresetName: string;

package/ui/Blocks/CommonGrid/hooks/useDeletePreset.js

@@ -0,0 +1,35 @@
+import { useCallback } from "react";
+import { useModal } from "../../Modal/hooks/useModal";
+var useDeletePreset = function useDeletePreset(param) {
+    var selectedPresetName = param.selectedPresetName, gridName = param.gridName, gridActions = param.gridActions, setSelectedPresetName = param.setSelectedPresetName;
+    var _useModal = useModal(), isDeletePresetModalOpen = _useModal.isOpen, onOpenDeletePresetModal = _useModal.onOpen, onCloseDeletePresetModal = _useModal.onClose, presetNameToDelete = _useModal.data;
+    var handleOpenDeletePresetModal = useCallback(function(presetName) {
+        return function(e) {
+            if (!presetName) return;
+            e.stopPropagation();
+            onOpenDeletePresetModal(presetName);
+        };
+    }, [
+        selectedPresetName
+    ]);
+    var handleDeletePreset = useCallback(function() {
+        var _gridActions_deletePreset;
+        if (!gridName || !presetNameToDelete) return;
+        (_gridActions_deletePreset = gridActions.deletePreset) === null || _gridActions_deletePreset === void 0 ? void 0 : _gridActions_deletePreset.call(gridActions, presetNameToDelete);
+        if (selectedPresetName === presetNameToDelete) {
+            setSelectedPresetName("");
+        }
+        onCloseDeletePresetModal();
+    }, [
+        gridName,
+        presetNameToDelete
+    ]);
+    return {
+        handleOpenDeletePresetModal: handleOpenDeletePresetModal,
+        isDeletePresetModalOpen: isDeletePresetModalOpen,
+        handleDeletePreset: handleDeletePreset,
+        onCloseDeletePresetModal: onCloseDeletePresetModal,
+        presetNameToDelete: presetNameToDelete
+    };
+};
+export { useDeletePreset };

package/ui/Blocks/CommonGrid/hooks/useEditReadAsColumn.d.ts

@@ -1,5 +1,4 @@
-import { CommonGridProps } from '../types';
-
+import type { CommonGridProps } from '../types';
 type ExcludedProps = 'components' | 'filters' | 'onBatchAction' | 'extraControlButtons';
 type Props = Omit<CommonGridProps, ExcludedProps>;
 type UseEditReadAsColumnHook = {

package/ui/Blocks/CommonGrid/hooks/useEditReadAsColumn.js

@@ -0,0 +1,93 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import { useCallback, useMemo } from "react";
+import withProps from "../HoC/withProps";
+import { RowActionsCell } from "../components/gridCells";
+import { EditReadPosition } from "../types";
+var useEditReadAsColumn = function useEditReadAsColumn(props) {
+    var _actionColumnDefinition_actionOptions;
+    var onRowAction = props.onRowAction, actionColumnDefinition = props.actionColumnDefinition, columnsDefinitions = props.columnsDefinitions, gridSelectors = props.gridSelectors, gridActions = props.gridActions, onRowEditClick = props.onRowEditClick, onRowReadClick = props.onRowReadClick;
+    var modifiedOnRowAction = useCallback(function(id, field, value, rowData) {
+        if (field === "row_edit" || field === "row_read") {
+            if (field === "row_edit" && onRowEditClick) onRowEditClick(id, value);
+            if (field === "row_read" && onRowReadClick) onRowReadClick(id, value);
+        } else if (onRowAction) {
+            return onRowAction(id, field, value, rowData);
+        }
+    }, [
+        onRowAction,
+        onRowEditClick,
+        onRowReadClick
+    ]);
+    var _ref = actionColumnDefinition || {}, canRowEdit = _ref.canRowEdit, canRowRead = _ref.canRowRead, addRowNumbers = _ref.addRowNumbers, _ref_stickTo = _ref.stickTo, stickTo = _ref_stickTo === void 0 ? "left" : _ref_stickTo, _ref_flexBasis = _ref.flexBasis, flexBasis = _ref_flexBasis === void 0 ? 20 : _ref_flexBasis;
+    var withCheckboxes = !!(actionColumnDefinition === null || actionColumnDefinition === void 0 ? void 0 : (_actionColumnDefinition_actionOptions = actionColumnDefinition.actionOptions) === null || _actionColumnDefinition_actionOptions === void 0 ? void 0 : _actionColumnDefinition_actionOptions.length) || (actionColumnDefinition === null || actionColumnDefinition === void 0 ? void 0 : actionColumnDefinition.forceCheckboxes);
+    var hasActions = canRowEdit || canRowRead || withCheckboxes || addRowNumbers;
+    var modifiedColumnsDefinitions = useMemo(function() {
+        var _gridSelectors_uxState;
+        var editReadColumnDefinition = {
+            name: "actions-cell-cg",
+            flexBasis: flexBasis,
+            filtering: withCheckboxes || addRowNumbers,
+            filteringType: "actions",
+            sorting: false,
+            sticky: !!hasActions,
+            stickTo: stickTo,
+            alwaysOn: true,
+            cellComponent: withProps({
+                actionColumnDefinition: actionColumnDefinition,
+                withCheckboxes: withCheckboxes,
+                addRowNumbers: actionColumnDefinition === null || actionColumnDefinition === void 0 ? void 0 : actionColumnDefinition.addRowNumbers,
+                checkedRows: gridSelectors === null || gridSelectors === void 0 ? void 0 : (_gridSelectors_uxState = gridSelectors.uxState) === null || _gridSelectors_uxState === void 0 ? void 0 : _gridSelectors_uxState.checkedRows,
+                onUxChange: gridActions === null || gridActions === void 0 ? void 0 : gridActions.handleUxChange
+            })(RowActionsCell)
+        };
+        if (stickTo === EditReadPosition.Left) {
+            return [
+                editReadColumnDefinition
+            ].concat(_to_consumable_array(columnsDefinitions));
+        } else {
+            return _to_consumable_array(columnsDefinitions).concat([
+                editReadColumnDefinition
+            ]);
+        }
+    }, [
+        addRowNumbers,
+        flexBasis,
+        stickTo,
+        hasActions,
+        columnsDefinitions,
+        withCheckboxes,
+        gridSelectors === null || gridSelectors === void 0 ? void 0 : gridSelectors.uxState,
+        actionColumnDefinition,
+        gridActions === null || gridActions === void 0 ? void 0 : gridActions.handleUxChange
+    ]);
+    return {
+        columnsDefinitions: modifiedColumnsDefinitions,
+        onRowAction: modifiedOnRowAction
+    };
+};
+var useEditReadAsColumn_default = useEditReadAsColumn;
+export { useEditReadAsColumn_default as default };

package/ui/Blocks/CommonGrid/hooks/useEvent.js

@@ -0,0 +1,17 @@
+import { useCallback, useLayoutEffect, useRef } from "react";
+var useEvent = function useEvent(callback) {
+    var ref = useRef(function() {
+        throw new Error("Cannot call an event handler while rendering.");
+    });
+    useLayoutEffect(function() {
+        ref.current = callback;
+    });
+    return useCallback(function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        var _ref_current;
+        return (_ref_current = ref.current) === null || _ref_current === void 0 ? void 0 : _ref_current.apply(null, args);
+    }, []);
+};
+export { useEvent };

package/ui/Blocks/CommonGrid/hooks/useFloatingButton.d.ts

@@ -1,4 +1,3 @@
 import { FloatingButtonProps, Item } from '../types';
-
 declare const useFloatingButton: (hasPermission: any, onClick?: () => void, options?: Item[]) => FloatingButtonProps | undefined;
 export default useFloatingButton;

package/ui/Blocks/CommonGrid/hooks/useFloatingButton.js

@@ -0,0 +1,16 @@
+import { useMemo } from "react";
+var useFloatingButton = function useFloatingButton(hasPermission, onClick, options) {
+    return useMemo(function() {
+        if (!hasPermission) return;
+        return {
+            onClick: onClick,
+            options: options
+        };
+    }, [
+        hasPermission,
+        onClick,
+        options
+    ]);
+};
+var useFloatingButton_default = useFloatingButton;
+export { useFloatingButton_default as default };

package/ui/Blocks/CommonGrid/hooks/useGridActionTrigger.d.ts

@@ -1,5 +1,4 @@
 import { RowProps, UxState, ActionColumn, OnBatchActionFn } from '../types';
-
 /**
  * hook for action selection and trigger
  * returns [subset of actions that are enabled, onSelect(value) - param1: selected action value]

package/ui/Blocks/CommonGrid/hooks/useGridActionTrigger.js

@@ -0,0 +1,44 @@
+import { useMemo, useCallback } from "react";
+import find from "lodash/find";
+var useGridActionTrigger = function useGridActionTrigger(rowsData, uxState) {
+    var actionOptions = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [], onBatchAction = arguments.length > 3 ? arguments[3] : void 0;
+    var actionRows = useMemo(function() {
+        return (rowsData || []).filter(function(row) {
+            var _uxState_checkedRows;
+            return (_uxState_checkedRows = uxState.checkedRows) === null || _uxState_checkedRows === void 0 ? void 0 : _uxState_checkedRows[row.id];
+        });
+    }, [
+        uxState,
+        rowsData
+    ]);
+    var enabledActions = useMemo(function() {
+        var actionsOptions = actionOptions || [];
+        return actionsOptions.filter(function(action) {
+            if (action.isEnabled) {
+                return action.isEnabled(actionRows);
+            } else {
+                return uxState.checkedRows && find(uxState.checkedRows, Boolean);
+            }
+        });
+    }, [
+        uxState,
+        actionRows,
+        actionOptions
+    ]);
+    var handleBatchAction = useCallback(function(value) {
+        var actionsOptions = actionOptions || [];
+        var action = actionsOptions.find(function(option) {
+            return option.value == value;
+        });
+        action && onBatchAction && onBatchAction(action, actionRows);
+    }, [
+        actionOptions,
+        onBatchAction,
+        actionRows
+    ]);
+    return [
+        enabledActions,
+        handleBatchAction
+    ];
+};
+export { useGridActionTrigger };

package/ui/Blocks/CommonGrid/hooks/useGridAutoRowsPerPage.d.ts

@@ -1,5 +1,4 @@
 import { GridActionsType } from '../types';
-
 type Props = {
     gridActions: GridActionsType;
     queryRowsParam?: number | string;

package/ui/Blocks/CommonGrid/hooks/useGridAutoRowsPerPage.js

@@ -0,0 +1,23 @@
+import { useEffect } from "react";
+import { rowsPerPageOptions } from "../utils/constants";
+var useGridAutoRowsPerPage = function useGridAutoRowsPerPage(param) {
+    var gridActions = param.gridActions, queryRowsParam = param.queryRowsParam, selectedRowsPerPage = param.selectedRowsPerPage, autoRowsPerPage = param.autoRowsPerPage, autoHeight = param.autoHeight;
+    useEffect(function() {
+        if (!autoHeight || queryRowsParam || !autoRowsPerPage) {
+            return;
+        }
+        var selectedOption = rowsPerPageOptions.find(function(option) {
+            return option.value === selectedRowsPerPage;
+        });
+        if (!selectedOption) {
+            if (autoRowsPerPage) {
+                var _gridActions_setRowsPerPage;
+                (_gridActions_setRowsPerPage = gridActions.setRowsPerPage) === null || _gridActions_setRowsPerPage === void 0 ? void 0 : _gridActions_setRowsPerPage.call(gridActions, autoRowsPerPage);
+            }
+        }
+    }, [
+        gridActions,
+        queryRowsParam
+    ]);
+};
+export { useGridAutoRowsPerPage };

package/ui/Blocks/CommonGrid/hooks/useManageColumn.d.ts

@@ -1,6 +1,5 @@
 import { DragEndEvent } from '@dnd-kit/core';
 import { CommonGridProps, GridActionsType, GridSelectorsType, ColumnDefinition } from '../types';
-
 type Props = {
     columns: CommonGridProps['columnsDefinitions'];
     gridActions: GridActionsType;
@@ -9,7 +8,7 @@ type Props = {
 };
 declare const useManageColumn: ({ columns, gridSelectors, gridActions, onClose }: Props) => {
     columnsConfigValues: string[];
-    setColumnsConfigOptions: import('react').Dispatch<import('react').SetStateAction<{
+    setColumnsConfigOptions: import("react").Dispatch<import("react").SetStateAction<{
         [x: string]: {
             isHidden?: boolean;
         };

package/ui/Blocks/CommonGrid/hooks/useManageColumn.js

@@ -0,0 +1,222 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { checksColumnsOrder, isColumnOn } from "../utils";
+var useManageColumn = function useManageColumn(param) {
+    var columns = param.columns, gridSelectors = param.gridSelectors, gridActions = param.gridActions, onClose = param.onClose;
+    var resetGrid = gridActions.resetGrid, setColumnConfig = gridActions.setColumnConfig, setColumnsOrder = gridActions.setColumnsOrder;
+    var columnConfig = gridSelectors.columnConfig, columnsOrder = gridSelectors.columnsOrder;
+    var initialColumnsOrder = useMemo(function() {
+        return columns === null || columns === void 0 ? void 0 : columns.map(function(col) {
+            return col.name;
+        });
+    }, [
+        columns
+    ]);
+    var columnsOrderValue = (columnsOrder === null || columnsOrder === void 0 ? void 0 : columnsOrder.length) ? columnsOrder : initialColumnsOrder;
+    var _useState = _sliced_to_array(useState(_object_spread({}, columnConfig !== null && columnConfig !== void 0 ? columnConfig : {})), 2), columnsConfigOptions = _useState[0], setColumnsConfigOptions = _useState[1];
+    var _useState1 = _sliced_to_array(useState(columnsOrderValue), 2), updatedColumnsOrder = _useState1[0], setUpdatedColumnsOrder = _useState1[1];
+    var columnsConfigValues = useMemo(function() {
+        return columns === null || columns === void 0 ? void 0 : columns.filter(function(column) {
+            var _columnsConfigOptions_column_name;
+            var isHidden = columnsConfigOptions === null || columnsConfigOptions === void 0 ? void 0 : (_columnsConfigOptions_column_name = columnsConfigOptions[column.name]) === null || _columnsConfigOptions_column_name === void 0 ? void 0 : _columnsConfigOptions_column_name.isHidden;
+            if ((column === null || column === void 0 ? void 0 : column.alwaysOn) || typeof isHidden === "boolean") return !isHidden;
+            if (!!column.defaultHidden && !!(columnsConfigOptions === null || columnsConfigOptions === void 0 ? void 0 : columnsConfigOptions[column.name])) return true;
+            else return !(column === null || column === void 0 ? void 0 : column.defaultHidden);
+        }).map(function(column) {
+            return column.name;
+        });
+    }, [
+        columnsConfigOptions,
+        columns
+    ]);
+    var onConfirmForm = useCallback(function() {
+        setColumnConfig === null || setColumnConfig === void 0 ? void 0 : setColumnConfig(columnsConfigOptions);
+        setColumnsOrder === null || setColumnsOrder === void 0 ? void 0 : setColumnsOrder(updatedColumnsOrder);
+        onClose === null || onClose === void 0 ? void 0 : onClose();
+    }, [
+        columnsConfigOptions,
+        updatedColumnsOrder,
+        onClose,
+        setColumnConfig,
+        setColumnsOrder
+    ]);
+    var resetColumnConfig = useCallback(function() {
+        setUpdatedColumnsOrder(initialColumnsOrder);
+        resetGrid === null || resetGrid === void 0 ? void 0 : resetGrid();
+        onClose === null || onClose === void 0 ? void 0 : onClose();
+        setColumnsConfigOptions({});
+    }, [
+        onClose,
+        resetGrid,
+        initialColumnsOrder,
+        columnConfig
+    ]);
+    var onCloseForm = useCallback(function() {
+        setUpdatedColumnsOrder(columnsOrderValue);
+        onClose === null || onClose === void 0 ? void 0 : onClose();
+        setColumnsConfigOptions(columnConfig || {});
+    }, [
+        columnsOrderValue,
+        onClose
+    ]);
+    var getSortedColumns = useCallback(function(orderValues, isManageModal) {
+        var list = columns.filter(function(column) {
+            return isManageModal ? !column.alwaysOff : isColumnOn(column, columnsConfigOptions);
+        });
+        var sortFunction = function sortFunction(col1, col2) {
+            var i = (orderValues || []).indexOf(col1.name);
+            var j = (orderValues || []).indexOf(col2.name);
+            if (orderValues && (orderValues === null || orderValues === void 0 ? void 0 : orderValues.length) > 0 && i === -1) {
+                return 0;
+            }
+            return i > j ? 1 : i < j ? -1 : 0;
+        };
+        var sortedList = _to_consumable_array(list).sort(sortFunction);
+        return sortedList;
+    }, [
+        columnConfig,
+        columnsConfigOptions,
+        columns
+    ]);
+    var displayColumnsDefinitions = useMemo(function() {
+        return getSortedColumns(columnsOrderValue, false);
+    }, [
+        columnsOrderValue,
+        columns,
+        columnsConfigOptions,
+        getSortedColumns
+    ]);
+    var manageColumnsFormDefinitions = useMemo(function() {
+        return getSortedColumns(updatedColumnsOrder, true);
+    }, [
+        updatedColumnsOrder
+    ]);
+    var handleDragEnd = useCallback(function() {
+        var isManageModal = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+        return function(event) {
+            var active = event.active, over = event.over;
+            if (!over || active.id === over.id) {
+                return;
+            }
+            var newOrderColumns = _to_consumable_array(updatedColumnsOrder);
+            var fromIndex = updatedColumnsOrder.findIndex(function(column) {
+                return column === active.id;
+            });
+            var toIndex = updatedColumnsOrder.findIndex(function(column) {
+                return column === over.id;
+            });
+            newOrderColumns.splice(fromIndex, 1);
+            newOrderColumns.splice(toIndex === -1 ? 0 : toIndex, 0, active.id);
+            if (!isManageModal) {
+                setColumnsOrder === null || setColumnsOrder === void 0 ? void 0 : setColumnsOrder(newOrderColumns);
+            }
+            setUpdatedColumnsOrder(newOrderColumns);
+        };
+    }, [
+        updatedColumnsOrder,
+        columnsOrderValue,
+        setColumnsOrder,
+        manageColumnsFormDefinitions,
+        displayColumnsDefinitions
+    ]);
+    useEffect(function() {
+        checksColumnsOrder(columnsOrderValue, columns);
+    }, []);
+    return {
+        columnsConfigValues: columnsConfigValues,
+        setColumnsConfigOptions: setColumnsConfigOptions,
+        onConfirmForm: onConfirmForm,
+        resetColumnConfig: resetColumnConfig,
+        handleDragEnd: handleDragEnd,
+        onCloseForm: onCloseForm,
+        displayColumnsDefinitions: displayColumnsDefinitions,
+        manageColumnsFormDefinitions: manageColumnsFormDefinitions
+    };
+};
+var useManageColumn_default = useManageColumn;
+export { useManageColumn_default as default };

package/ui/Blocks/CommonGrid/hooks/usePresetFileHandlers.d.ts

@@ -1,6 +1,5 @@
-import { ChangeEvent, RefObject } from 'react';
-import { GridActionsType, GridSelectorsType } from '../types';
-
+import { type ChangeEvent, type RefObject } from 'react';
+import { type GridActionsType, type GridSelectorsType } from '../types';
 type FileHandlersProps = {
     gridName?: string;
     gridActions: GridActionsType;