@mailstep/design-system 0.8.26 → 0.8.27

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

@@ -0,0 +1,127 @@
+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 _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 ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+import { useRef, useCallback } from "react";
+import { i18n } from "@lingui/core";
+import omit from "lodash/omit";
+var usePresetFileHandlers = function usePresetFileHandlers(param) {
+    var gridName = param.gridName, gridActions = param.gridActions, gridSelectors = param.gridSelectors;
+    var fileInputRef = useRef(null);
+    var handleExportPresets = useCallback(function() {
+        if (!gridName) return;
+        var gridConfig = {
+            gridName: gridName
+        };
+        var data = _object_spread_props(_object_spread({}, gridSelectors.presets), {
+            _: gridConfig
+        });
+        var blob = new Blob([
+            JSON.stringify(data, null, 2)
+        ], {
+            type: "application/json"
+        });
+        var link = document.createElement("a");
+        link.href = URL.createObjectURL(blob);
+        link.download = "".concat(gridName, "Presets.json");
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    }, [
+        gridName,
+        gridSelectors.presets
+    ]);
+    var handleImportPresets = useCallback(function(event) {
+        var _event_target_files;
+        if (!gridName) return;
+        var file = (_event_target_files = event.target.files) === null || _event_target_files === void 0 ? void 0 : _event_target_files[0];
+        if (!file) return;
+        var reader = new FileReader();
+        reader.readAsText(file);
+        reader.onload = function(e) {
+            try {
+                var _e_target, _gridActions_setPresets;
+                var fileContent = JSON.parse((_e_target = e.target) === null || _e_target === void 0 ? void 0 : _e_target.result);
+                var gridConfig = fileContent._;
+                if (gridConfig && gridConfig.gridName !== gridName) {
+                    throw new Error(i18n._({
+                        id: "dataGrid.importPresets.gridNameNotSame",
+                        message: "Grid name in file is not the same as current grid."
+                    }));
+                }
+                (_gridActions_setPresets = gridActions.setPresets) === null || _gridActions_setPresets === void 0 ? void 0 : _gridActions_setPresets.call(gridActions, omit(fileContent, "_"));
+            } catch (error) {
+                console.warn(error);
+                alert(i18n._({
+                    id: "dataGrid.importPresets.error",
+                    message: "Error with importing files."
+                }) + String(error));
+            } finally{
+                if (fileInputRef.current) {
+                    fileInputRef.current.value = "";
+                }
+            }
+        };
+    }, [
+        gridName
+    ]);
+    var handleImportButtonClick = useCallback(function() {
+        var _fileInputRef_current;
+        (_fileInputRef_current = fileInputRef.current) === null || _fileInputRef_current === void 0 ? void 0 : _fileInputRef_current.click();
+    }, []);
+    return {
+        fileInputRef: fileInputRef,
+        handleImportPresets: handleImportPresets,
+        handleExportPresets: handleExportPresets,
+        handleImportButtonClick: handleImportButtonClick
+    };
+};
+export { usePresetFileHandlers };

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

@@ -0,0 +1,60 @@
+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 { useState } from "react";
+import { useModal } from "../../Modal/hooks/useModal";
+var usePresetState = function usePresetState() {
+    var _useModal = useModal(), isPresetsModalOpen = _useModal.isOpen, onOpenPresetsModal = _useModal.onOpen, onClosePresetsModal = _useModal.onClose;
+    var _useState = _sliced_to_array(useState(""), 2), selectedPresetName = _useState[0], setSelectedPresetName = _useState[1];
+    return {
+        isPresetsModalOpen: isPresetsModalOpen,
+        onOpenPresetsModal: onOpenPresetsModal,
+        onClosePresetsModal: onClosePresetsModal,
+        selectedPresetName: selectedPresetName,
+        setSelectedPresetName: setSelectedPresetName
+    };
+};
+export { usePresetState };

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

@@ -1,6 +1,5 @@
 import { ChangeEvent } from 'react';
 import { ColumnDefinition, CommonGridProps, FiltersConfig, GridActionsType, GridSelectorsType } from '../types';
-
 type Props = {
     gridActions: GridActionsType;
     gridSelectors: GridSelectorsType;
@@ -11,7 +10,7 @@ type Props = {
 };
 declare const useQuickFilter: ({ gridActions, gridSelectors, quickFilter, columns, filters }: Props) => {
     searchedValue: string;
-    translatedValue: import('react').ReactNode;
+    translatedValue: import("react").ReactNode;
     onChangeInputValue: (e: ChangeEvent<HTMLInputElement>) => void;
     onClearSettings: () => void;
     onDisplayInput: () => void;
@@ -19,6 +18,6 @@ declare const useQuickFilter: ({ gridActions, gridSelectors, quickFilter, column
     onClear: () => void;
     isMobileInputView: boolean;
     isMobile: boolean;
-    filter: import('../types').Filtering | undefined;
+    filter: import("../types").Filtering | undefined;
 };
 export default useQuickFilter;

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

@@ -0,0 +1,151 @@
+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, useEffect, useState } from "react";
+import { useCheckDeviceWidth } from "../../../utils/CheckDeviceWidth/checkDeviceWidth";
+import { getTranslatedValue } from "../components/ManageColumnForm/utils";
+import { createFilterType } from "../utils";
+import { useAddFilter } from "./useAddFilter";
+var defaultVoidFunction = function defaultVoidFunction() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    return null;
+};
+var useQuickFilter = function useQuickFilter(param) {
+    var gridActions = param.gridActions, gridSelectors = param.gridSelectors, quickFilter = param.quickFilter, columns = param.columns, filters = param.filters;
+    var _filter_quickFilter, _filters_filterType_defaultExtraProps;
+    var _gridActions_addFilter = gridActions.addFilter, addFilter = _gridActions_addFilter === void 0 ? defaultVoidFunction : _gridActions_addFilter, _gridActions_clearSettings = gridActions.clearSettings, clearSettings = _gridActions_clearSettings === void 0 ? defaultVoidFunction : _gridActions_clearSettings;
+    var filter = gridSelectors.filter;
+    var isMobile = useCheckDeviceWidth().isMobile;
+    var _useState = _sliced_to_array(useState(""), 2), searchedValue = _useState[0], setSearchedValue = _useState[1];
+    var _useState1 = _sliced_to_array(useState(false), 2), displayInput = _useState1[0], setDisplayInput = _useState1[1];
+    var handleAddFilter = useAddFilter(addFilter);
+    var quickFilterValues = quickFilter ? filter === null || filter === void 0 ? void 0 : (_filter_quickFilter = filter[quickFilter]) === null || _filter_quickFilter === void 0 ? void 0 : _filter_quickFilter.value : void 0;
+    var searchedColumnsDefinitions = (columns === null || columns === void 0 ? void 0 : columns.find(function(item) {
+        return item.name === quickFilter;
+    })) || null;
+    var filterType = createFilterType(searchedColumnsDefinitions || {});
+    var filtersDefaultComparator = (filters === null || filters === void 0 ? void 0 : (_filters_filterType_defaultExtraProps = filters[filterType].defaultExtraProps) === null || _filters_filterType_defaultExtraProps === void 0 ? void 0 : _filters_filterType_defaultExtraProps.defaultComparator) || "eq";
+    var searchComparator = quickFilterValues && quickFilterValues.comparator || filtersDefaultComparator;
+    var isMobileInputView = isMobile && displayInput;
+    useEffect(function() {
+        if (quickFilterValues) {
+            setSearchedValue(quickFilterValues.value);
+        } else {
+            setSearchedValue("");
+        }
+    }, [
+        quickFilterValues,
+        quickFilter,
+        setSearchedValue
+    ]);
+    useEffect(function() {
+        if (isMobile) {
+            setDisplayInput(false);
+        } else {
+            setDisplayInput(true);
+        }
+    }, [
+        isMobile
+    ]);
+    var onChangeInputValue = useCallback(function(e) {
+        setSearchedValue(e.target.value);
+        var value = {
+            comparator: searchComparator,
+            value: e.target.value
+        };
+        searchedColumnsDefinitions && handleAddFilter(value, searchedColumnsDefinitions);
+    }, [
+        setSearchedValue,
+        searchComparator,
+        handleAddFilter,
+        searchedColumnsDefinitions
+    ]);
+    var onClear = useCallback(function() {
+        setSearchedValue("");
+        onChangeInputValue({
+            target: {
+                value: ""
+            }
+        });
+        if (isMobile) {
+            setDisplayInput(false);
+        } else {
+            setDisplayInput(true);
+        }
+    }, [
+        setSearchedValue,
+        isMobile,
+        onChangeInputValue,
+        setDisplayInput
+    ]);
+    var onDisplayInput = useCallback(function() {
+        setDisplayInput(true);
+    }, []);
+    var onClearSettings = useCallback(function() {
+        clearSettings === null || clearSettings === void 0 ? void 0 : clearSettings();
+        setSearchedValue === null || setSearchedValue === void 0 ? void 0 : setSearchedValue("");
+    }, [
+        clearSettings,
+        setSearchedValue
+    ]);
+    var translatedValue = getTranslatedValue(searchedColumnsDefinitions);
+    return {
+        searchedValue: searchedValue,
+        translatedValue: translatedValue,
+        onChangeInputValue: onChangeInputValue,
+        onClearSettings: onClearSettings,
+        onDisplayInput: onDisplayInput,
+        displayInput: displayInput,
+        onClear: onClear,
+        isMobileInputView: isMobileInputView,
+        isMobile: isMobile,
+        filter: filter
+    };
+};
+var useQuickFilter_default = useQuickFilter;
+export { useQuickFilter_default as default };

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

@@ -1,5 +1,4 @@
-import { default as React } from 'react';
+import React from 'react';
 import { RowProps, UxState } from '../types';
-
 declare const useRowsKeyControls: (rowsData: RowProps[], uxState: UxState, onUxChange?: (uxKey: keyof UxState, uxValue: any) => void) => (e: React.KeyboardEvent<HTMLDivElement>) => void;
 export default useRowsKeyControls;

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

@@ -0,0 +1,24 @@
+import React from "react";
+var useRowsKeyControls = function useRowsKeyControls(rowsData, uxState, onUxChange) {
+    return React.useCallback(function(e) {
+        var _rowsData_, _rowsData_1;
+        var selectedRowId = uxState.selectedRow;
+        if (!selectedRowId) return;
+        var selectedRowIdx = rowsData.findIndex(function(row) {
+            return row.id === selectedRowId;
+        });
+        var previousRowId = (_rowsData_ = rowsData[selectedRowIdx - 1]) === null || _rowsData_ === void 0 ? void 0 : _rowsData_.id;
+        var nextRowId = (_rowsData_1 = rowsData[selectedRowIdx + 1]) === null || _rowsData_1 === void 0 ? void 0 : _rowsData_1.id;
+        var isFirst = selectedRowIdx === 0;
+        var isLast = selectedRowIdx === rowsData.length - 1;
+        if (e.key === "ArrowUp" && !isFirst) onUxChange === null || onUxChange === void 0 ? void 0 : onUxChange("selectedRow", previousRowId);
+        if (e.key === "ArrowDown" && !isLast) onUxChange === null || onUxChange === void 0 ? void 0 : onUxChange("selectedRow", nextRowId);
+        if (e.key === "Escape") onUxChange === null || onUxChange === void 0 ? void 0 : onUxChange("selectedRow", null);
+    }, [
+        uxState,
+        rowsData,
+        onUxChange
+    ]);
+};
+var useRowsKeyControls_default = useRowsKeyControls;
+export { useRowsKeyControls_default as default };

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

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

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

@@ -0,0 +1,83 @@
+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, useEffect } from "react";
+import isEqual from "lodash/isEqual";
+var useSelectPreset = function useSelectPreset(param) {
+    var gridName = param.gridName, gridActions = param.gridActions, gridSelectors = param.gridSelectors, setSelectedPresetName = param.setSelectedPresetName, onClosePresetsModal = param.onClosePresetsModal;
+    var gridPresets = gridSelectors === null || gridSelectors === void 0 ? void 0 : gridSelectors.presets;
+    var filters = gridSelectors === null || gridSelectors === void 0 ? void 0 : gridSelectors.filter;
+    var handleSelectPreset = useCallback(function(presetName, filters2) {
+        return function() {
+            var _gridActions_setFilters;
+            setSelectedPresetName(presetName);
+            (_gridActions_setFilters = gridActions.setFilters) === null || _gridActions_setFilters === void 0 ? void 0 : _gridActions_setFilters.call(gridActions, filters2);
+            onClosePresetsModal();
+        };
+    }, [
+        gridActions
+    ]);
+    useEffect(function() {
+        var _Object_entries;
+        if (!gridName || !gridPresets) return;
+        var activePreset = (_Object_entries = Object.entries(gridPresets)) === null || _Object_entries === void 0 ? void 0 : _Object_entries.find(function(param) {
+            var _param = _sliced_to_array(param, 2), presetName = _param[0], presetFilters = _param[1];
+            return isEqual(presetFilters, filters);
+        });
+        if (activePreset) {
+            setSelectedPresetName(activePreset[0]);
+        } else {
+            setSelectedPresetName("");
+        }
+    }, [
+        filters,
+        gridPresets
+    ]);
+    return {
+        handleSelectPreset: handleSelectPreset
+    };
+};
+export { useSelectPreset };

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

@@ -1,5 +1,4 @@
-import { RowProps, GridActionsType, UxState } from '../types';
-
+import type { RowProps, GridActionsType, UxState } from '../types';
 /**
  * hook for checkbox that select and unselects all row
  * returns [checked state, toggleAllHandler()] for checkbox

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

@@ -0,0 +1,30 @@
+import { useMemo, useCallback } from "react";
+var useToggleAllCheckbox = function useToggleAllCheckbox(rowsData, uxState, handleUxChange) {
+    var allChecked = useMemo(function() {
+        return rowsData && (rowsData || []).length >= 1 && rowsData.every(function(row) {
+            var _uxState_checkedRows;
+            return uxState === null || uxState === void 0 ? void 0 : (_uxState_checkedRows = uxState.checkedRows) === null || _uxState_checkedRows === void 0 ? void 0 : _uxState_checkedRows[row.id];
+        });
+    }, [
+        rowsData,
+        uxState === null || uxState === void 0 ? void 0 : uxState.checkedRows
+    ]);
+    var toggleAllHandler = useCallback(function() {
+        var checkedRows = {};
+        if (!allChecked && rowsData) {
+            rowsData.forEach(function(row) {
+                checkedRows[row.id] = true;
+            });
+        }
+        handleUxChange === null || handleUxChange === void 0 ? void 0 : handleUxChange("checkedRows", checkedRows);
+    }, [
+        handleUxChange,
+        rowsData,
+        allChecked
+    ]);
+    return [
+        !!allChecked,
+        toggleAllHandler
+    ];
+};
+export { useToggleAllCheckbox };

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

@@ -1,4 +1,3 @@
 import { RowProps, GridActionsType, UxState } from '../types';
-
 declare const useUxReset: (rowsData: RowProps[], uxState: UxState, clearUxState: GridActionsType["clearUxState"]) => any;
 export default useUxReset;

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

@@ -0,0 +1,65 @@
+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 React from "react";
+var useUxReset = function useUxReset(rowsData, uxState, clearUxState) {
+    var _React_useState = _sliced_to_array(React.useState("|"), 2), previous = _React_useState[0], setPrevious = _React_useState[1];
+    React.useEffect(function() {
+        var ids = (rowsData || []).map(function(row) {
+            return row.id;
+        }).join("|");
+        if (ids !== previous) {
+            if (clearUxState && (uxState.checkedRows && Object.keys(uxState.checkedRows).length || uxState.selectedRow)) {
+                clearUxState();
+            }
+        }
+        setPrevious(ids);
+    }, [
+        rowsData
+    ]);
+};
+var useUxReset_default = useUxReset;
+export { useUxReset_default as default };

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

@@ -1,11 +1,10 @@
-import { default as CommonGrid } from './CommonGridContainer';
-import { default as withReduxActions } from './HoC/withReduxActions';
-import { default as reducer, actionPrefix, createActions, createSelectors, createFullSelector, actionTypes } from './store';
-import { default as useFloatingButton } from './hooks/useFloatingButton';
-import { useAddFilter } from './hooks/useAddFilter';
-import { useEvent } from './hooks/useEvent';
-
+import CommonGrid from './CommonGridContainer';
+import withReduxActions from './HoC/withReduxActions';
+import reducer, { actionPrefix, createActions, createSelectors, createFullSelector, actionTypes } from './store';
+import useFloatingButton from './hooks/useFloatingButton';
 import * as Types from './types';
 export * from './components/gridCells';
+import { useAddFilter } from './hooks/useAddFilter';
+import { useEvent } from './hooks/useEvent';
 export default CommonGrid;
 export { withReduxActions, reducer, actionPrefix, actionTypes, createActions, createSelectors, createFullSelector, Types, useFloatingButton, useAddFilter, useEvent, };

package/ui/Blocks/CommonGrid/index.js

@@ -0,0 +1,10 @@
+import CommonGrid from "./CommonGridContainer";
+import withReduxActions from "./HoC/withReduxActions";
+import reducer, { actionPrefix, createActions, createSelectors, createFullSelector, actionTypes } from "./store";
+import useFloatingButton from "./hooks/useFloatingButton";
+import * as Types from "./types";
+export * from "./components/gridCells";
+import { useAddFilter } from "./hooks/useAddFilter";
+import { useEvent } from "./hooks/useEvent";
+var CommonGrid_default = CommonGrid;
+export { Types, actionPrefix, actionTypes, createActions, createFullSelector, createSelectors, CommonGrid_default as default, reducer, useAddFilter, useEvent, useFloatingButton, withReduxActions };

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

@@ -1,5 +1,4 @@
-import { FilterProps, SortingValueType, InitProps, GridState, GridSelectorsType, ColumnConfig, Filtering, GridPresets } from '../types';
-
+import type { FilterProps, SortingValueType, InitProps, GridState, GridSelectorsType, ColumnConfig, Filtering, GridPresets } from '../types';
 type DefaultRootState = {};
 export type MultiState = Record<string, GridState>;
 export declare const initialState: GridState;