intelicoreact 1.5.41 → 1.6.0

package/dist/Functions/useInputHighlightError.js

@@ -1,59 +1,110 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.useInputHighlightError = exports.default = void 0;
-var _react = _interopRequireWildcard(require("react"));
-var _index = require("../Constants/index.constants");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const useInputHighlightError = _ref => {
-  let {
-    value,
-    blinkTime,
-    isUseErrorsBlink
-  } = _ref;
-  const DEFAULT_BLINK_TIME = 100;
-  const [isToHighlightError, setIsToHighlightError] = (0, _react.useState)(false);
-  const [isAttemptToChange, setIsAttemptToChange] = (0, _react.useState)(false);
-  const [prevValue, setPreviousValue] = (0, _react.useState)(value);
-  function hasHighlightError(e) {
-    const changedValue = `${value ?? ""}`;
-    const previousValue = `${prevValue ?? ""}`;
-    const short = previousValue.length <= changedValue.length ? previousValue : changedValue;
-    const long = previousValue.length > changedValue.length ? previousValue : changedValue;
-    const infoAboutDifferencesSameness = short.split("").reduce((acc, symbol, idx) => {
-      if (acc.countOn && symbol === long[idx]) acc.same.push(symbol);else {
-        acc.countOn = false;
-        acc.differences.push([idx, symbol]);
-      }
-      return acc;
-    }, {
-      same: [],
-      countOn: true,
-      differences: []
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
     });
-    const samePart = infoAboutDifferencesSameness.same.join("");
-    const differencesLength = infoAboutDifferencesSameness.differences.length;
-    const currentSet = changedValue?.replace(samePart, "");
-    if (!_index.KEYBOARD_SERVICE_KEYS.includes(e.key) && changedValue === previousValue) setIsAttemptToChange(!(!differencesLength && e.key === currentSet));
-  }
-  (0, _react.useEffect)(() => {
-    if (isUseErrorsBlink && isAttemptToChange) {
-      setIsAttemptToChange(null);
-      setIsToHighlightError(true);
-      setTimeout(() => {
-        setIsToHighlightError(false);
-      }, blinkTime || DEFAULT_BLINK_TIME);
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    useInputHighlightError: function() {
+        return useInputHighlightError;
     }
-  }, [isAttemptToChange]);
-  return {
-    isToHighlightError,
-    setPreviousValue,
-    setIsToHighlightError,
-    hasHighlightError
-  };
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _indexconstants = require("../Constants/index.constants");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const useInputHighlightError = ({ value, blinkTime, isUseErrorsBlink })=>{
+    const DEFAULT_BLINK_TIME = 100;
+    const [isToHighlightError, setIsToHighlightError] = (0, _react.useState)(false);
+    const [isAttemptToChange, setIsAttemptToChange] = (0, _react.useState)(false);
+    const [prevValue, setPreviousValue] = (0, _react.useState)(value);
+    function hasHighlightError(e) {
+        const changedValue = `${value !== null && value !== void 0 ? value : ""}`;
+        const previousValue = `${prevValue !== null && prevValue !== void 0 ? prevValue : ""}`;
+        const short = previousValue.length <= changedValue.length ? previousValue : changedValue;
+        const long = previousValue.length > changedValue.length ? previousValue : changedValue;
+        const infoAboutDifferencesSameness = short.split("").reduce((acc, symbol, idx)=>{
+            if (acc.countOn && symbol === long[idx]) acc.same.push(symbol);
+            else {
+                acc.countOn = false;
+                acc.differences.push([
+                    idx,
+                    symbol
+                ]);
+            }
+            return acc;
+        }, {
+            same: [],
+            countOn: true,
+            differences: []
+        });
+        const samePart = infoAboutDifferencesSameness.same.join("");
+        const differencesLength = infoAboutDifferencesSameness.differences.length;
+        const currentSet = changedValue === null || changedValue === void 0 ? void 0 : changedValue.replace(samePart, "");
+        if (!_indexconstants.KEYBOARD_SERVICE_KEYS.includes(e.key) && changedValue === previousValue) setIsAttemptToChange(!(!differencesLength && e.key === currentSet));
+    }
+    (0, _react.useEffect)(()=>{
+        if (isUseErrorsBlink && isAttemptToChange) {
+            setIsAttemptToChange(null);
+            setIsToHighlightError(true);
+            setTimeout(()=>{
+                setIsToHighlightError(false);
+            }, blinkTime || DEFAULT_BLINK_TIME);
+        }
+    }, [
+        isAttemptToChange
+    ]);
+    return {
+        isToHighlightError,
+        setPreviousValue,
+        setIsToHighlightError,
+        hasHighlightError
+    };
 };
-exports.useInputHighlightError = useInputHighlightError;
-var _default = exports.default = useInputHighlightError;
+const _default = useInputHighlightError;

package/dist/Functions/useIsMobile/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _useIsMobile = /*#__PURE__*/ _interop_require_default(require("./useIsMobile"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const _default = _useIsMobile.default;

package/dist/Functions/useIsMobile/useIsMobile.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = require("react");
+/**
+ * Hook to detect if the current device is a mobile device
+ * @param props - Configuration options
+ * @param props.isWithoutWidthCheck - If true, only checks user agent without width verification
+ * @returns Object containing isMobile flag
+ */ function useIsMobile({ isWithoutWidthCheck = false } = {}) {
+    const getIsMobile = ()=>{
+        return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+    };
+    const [isMobile, setIsMobile] = (0, _react.useState)(getIsMobile());
+    (0, _react.useEffect)(()=>{
+        if (getIsMobile()) {
+            setIsMobile(true);
+        }
+    }, [
+        navigator.userAgent
+    ]);
+    return {
+        isMobile: isMobile && (isWithoutWidthCheck || window.screen.width <= 768)
+    };
+}
+const _default = useIsMobile;

package/dist/Functions/useIsMobile/useIsMobile.test.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = require("@testing-library/react");
+const _useIsMobile = /*#__PURE__*/ _interop_require_default(require("./useIsMobile"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+describe('useIsMobile', ()=>{
+    const originalNavigator = window.navigator;
+    const originalScreen = window.screen;
+    beforeEach(()=>{
+        jest.clearAllMocks();
+    });
+    afterEach(()=>{
+        Object.defineProperty(window, 'navigator', {
+            value: originalNavigator,
+            writable: true
+        });
+        Object.defineProperty(window, 'screen', {
+            value: originalScreen,
+            writable: true
+        });
+    });
+    const mockUserAgent = (userAgent)=>{
+        Object.defineProperty(window.navigator, 'userAgent', {
+            value: userAgent,
+            writable: true
+        });
+    };
+    const mockScreenWidth = (width)=>{
+        Object.defineProperty(window.screen, 'width', {
+            value: width,
+            writable: true
+        });
+    };
+    it('should detect mobile device based on user agent', ()=>{
+        mockUserAgent('iPhone');
+        mockScreenWidth(375);
+        const { result } = (0, _react.renderHook)(()=>(0, _useIsMobile.default)());
+        expect(result.current.isMobile).toBe(true);
+    });
+    it('should detect desktop device based on user agent', ()=>{
+        mockUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');
+        mockScreenWidth(1920);
+        const { result } = (0, _react.renderHook)(()=>(0, _useIsMobile.default)());
+        expect(result.current.isMobile).toBe(false);
+    });
+    it('should respect width check when isWithoutWidthCheck is false', ()=>{
+        mockUserAgent('iPhone');
+        mockScreenWidth(1024);
+        const { result } = (0, _react.renderHook)(()=>(0, _useIsMobile.default)({
+                isWithoutWidthCheck: false
+            }));
+        expect(result.current.isMobile).toBe(false);
+    });
+    it('should ignore width check when isWithoutWidthCheck is true', ()=>{
+        mockUserAgent('iPhone');
+        mockScreenWidth(1024);
+        const { result } = (0, _react.renderHook)(()=>(0, _useIsMobile.default)({
+                isWithoutWidthCheck: true
+            }));
+        expect(result.current.isMobile).toBe(true);
+    });
+    describe('mobile devices detection', ()=>{
+        const mobileDevices = [
+            'Android',
+            'webOS',
+            'iPhone',
+            'iPad',
+            'iPod',
+            'BlackBerry',
+            'IEMobile',
+            'Opera Mini'
+        ];
+        mobileDevices.forEach((device)=>{
+            it(`should detect ${device} as mobile device`, ()=>{
+                mockUserAgent(device);
+                mockScreenWidth(375);
+                const { result } = (0, _react.renderHook)(()=>(0, _useIsMobile.default)());
+                expect(result.current.isMobile).toBe(true);
+            });
+        });
+    });
+    it('should update isMobile state when userAgent changes', ()=>{
+        mockUserAgent('Desktop');
+        mockScreenWidth(1920);
+        const { result, rerender } = (0, _react.renderHook)(()=>(0, _useIsMobile.default)());
+        expect(result.current.isMobile).toBe(false);
+        mockUserAgent('iPhone');
+        mockScreenWidth(375);
+        rerender();
+        expect(result.current.isMobile).toBe(true);
+    });
+    it('should return only isMobile property', ()=>{
+        const { result } = (0, _react.renderHook)(()=>(0, _useIsMobile.default)());
+        expect(Object.keys(result.current)).toEqual([
+            'isMobile'
+        ]);
+    });
+});

package/dist/Functions/useKeyPress/useHandleKeyPress.js

@@ -1,45 +1,52 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.default = void 0;
-var _react = require("react");
-var _useKeyPress = _interopRequireDefault(require("./useKeyPress"));
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = require("react");
+const _useKeyPress = /*#__PURE__*/ _interop_require_default(require("./useKeyPress"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 /**
- * @function useHandleKeyPress
- * @param {Object} props - объект с действиями и состоянием обновления.
- * @param {Function} props.escCallback - функция, которая вызывается при нажатии клавиши 'Escape'.
- * @param {Function} props.enterCallback - функция, которая вызывается при нажатии клавиши 'Enter'.
- * @returns {void} - возвращает null.
- * @description
- * Хук `useHandleKeyPress` используется для создания действий при нажатии определённых клавиш ('Escape' и 'Enter').
- * Если props.escCallback и props.enterCallback определены и передано состояние обновления (isUpdating) равное false,
- * то при нажатии на клавиши 'Escape' или 'Enter' будут вызваны соответственные функции обратного вызова (escCallback и enterCallback).
+ * A hook that handles Enter and Escape key press events
+ *
+ * @param props - Configuration object for key press handling
+ * @param props.escCallback - Function to be called when Escape key is pressed
+ * @param props.enterCallback - Function to be called when Enter key is pressed
+ * @param props.withClamping - Whether to allow key repeat events (default: true)
  *
  * @example
+ * ```tsx
  * function Component() {
  *   useHandleKeyPress({
  *     escCallback: () => console.log('Esc pressed'),
  *     enterCallback: () => console.log('Enter pressed'),
  *   });
- *
- *   // ...
  * }
- *
- */
-const useHandleKeyPress = _ref => {
-  let {
-    escCallback,
-    enterCallback,
-    withClamping = true
-  } = _ref;
-  const isPressEnter = (0, _useKeyPress.default)("Enter", withClamping);
-  const isPressEscape = (0, _useKeyPress.default)("Escape", withClamping);
-  (0, _react.useEffect)(() => {
-    if (isPressEnter && typeof enterCallback === "function") enterCallback();
-    if (isPressEscape && typeof escCallback === "function") escCallback();
-  }, [enterCallback, escCallback, isPressEnter, isPressEscape]);
-};
-var _default = exports.default = useHandleKeyPress;
+ * ```
+ */ function useHandleKeyPress({ escCallback, enterCallback, withClamping = true }) {
+    const isPressEnter = (0, _useKeyPress.default)('Enter', withClamping);
+    const isPressEscape = (0, _useKeyPress.default)('Escape', withClamping);
+    (0, _react.useEffect)(()=>{
+        if (isPressEnter && typeof enterCallback === 'function') {
+            enterCallback();
+        }
+        if (isPressEscape && typeof escCallback === 'function') {
+            escCallback();
+        }
+    }, [
+        enterCallback,
+        escCallback,
+        isPressEnter,
+        isPressEscape
+    ]);
+}
+const _default = useHandleKeyPress;

package/dist/Functions/useKeyPress/useHandleKeyPress.test.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = require("@testing-library/react");
+const _useHandleKeyPress = /*#__PURE__*/ _interop_require_default(require("./useHandleKeyPress"));
+const _useKeyPress = /*#__PURE__*/ _interop_require_default(require("./useKeyPress"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// Мокаем хук useKeyPress
+jest.mock('./useKeyPress');
+const mockedUseKeyPress = _useKeyPress.default;
+describe('useHandleKeyPress', ()=>{
+    // Очищаем моки перед каждым тестом
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        // По умолчанию клавиши не нажаты
+        mockedUseKeyPress.mockReturnValue(false);
+    });
+    it('should call enterCallback when Enter is pressed', ()=>{
+        const enterCallback = jest.fn();
+        const escCallback = jest.fn();
+        // Симулируем нажатие Enter
+        mockedUseKeyPress.mockReturnValueOnce(true) // для Enter
+        .mockReturnValueOnce(false); // для Escape
+        (0, _react.renderHook)(()=>(0, _useHandleKeyPress.default)({
+                enterCallback,
+                escCallback
+            }));
+        expect(enterCallback).toHaveBeenCalledTimes(1);
+        expect(escCallback).not.toHaveBeenCalled();
+    });
+    it('should call escCallback when Escape is pressed', ()=>{
+        const enterCallback = jest.fn();
+        const escCallback = jest.fn();
+        // Симулируем нажатие Escape
+        mockedUseKeyPress.mockReturnValueOnce(false) // для Enter
+        .mockReturnValueOnce(true); // для Escape
+        (0, _react.renderHook)(()=>(0, _useHandleKeyPress.default)({
+                enterCallback,
+                escCallback
+            }));
+        expect(escCallback).toHaveBeenCalledTimes(1);
+        expect(enterCallback).not.toHaveBeenCalled();
+    });
+    it('should not call callbacks when no keys are pressed', ()=>{
+        const enterCallback = jest.fn();
+        const escCallback = jest.fn();
+        // Никакие клавиши не нажаты
+        mockedUseKeyPress.mockReturnValue(false);
+        (0, _react.renderHook)(()=>(0, _useHandleKeyPress.default)({
+                enterCallback,
+                escCallback
+            }));
+        expect(enterCallback).not.toHaveBeenCalled();
+        expect(escCallback).not.toHaveBeenCalled();
+    });
+    it('should handle undefined callbacks gracefully', ()=>{
+        // Проверяем, что хук не выбрасывает ошибку при отсутствии callback'ов
+        expect(()=>{
+            (0, _react.renderHook)(()=>(0, _useHandleKeyPress.default)({
+                    withClamping: true
+                }));
+        }).not.toThrow();
+    });
+    it('should pass withClamping parameter to useKeyPress', ()=>{
+        (0, _react.renderHook)(()=>(0, _useHandleKeyPress.default)({
+                withClamping: false
+            }));
+        // Проверяем, что useKeyPress вызывается с правильными параметрами
+        expect(mockedUseKeyPress).toHaveBeenCalledWith('Enter', false);
+        expect(mockedUseKeyPress).toHaveBeenCalledWith('Escape', false);
+    });
+    it('should use default withClamping value when not provided', ()=>{
+        (0, _react.renderHook)(()=>(0, _useHandleKeyPress.default)({}));
+        // Проверяем, что useKeyPress вызывается с дефолтным значением withClamping
+        expect(mockedUseKeyPress).toHaveBeenCalledWith('Enter', true);
+        expect(mockedUseKeyPress).toHaveBeenCalledWith('Escape', true);
+    });
+    it('should properly handle effect cleanup', ()=>{
+        const enterCallback = jest.fn();
+        const escCallback = jest.fn();
+        const { unmount } = (0, _react.renderHook)(()=>(0, _useHandleKeyPress.default)({
+                enterCallback,
+                escCallback
+            }));
+        unmount();
+        // После unmount новые нажатия клавиш не должны вызывать callbacks
+        mockedUseKeyPress.mockReturnValueOnce(true).mockReturnValueOnce(true);
+        expect(enterCallback).not.toHaveBeenCalled();
+        expect(escCallback).not.toHaveBeenCalled();
+    });
+});

package/dist/Functions/useKeyPress/useKeyPress.js

@@ -1,43 +1,52 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.default = void 0;
-var _react = require("react");
-const useKeyPress = function (targetKey) {
-  let clamping = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  const [keyPressed, setKeyPressed] = (0, _react.useState)(false);
-  const downHandler = (0, _react.useCallback)(_ref => {
-    let {
-      key,
-      repeat
-    } = _ref;
-    if (key === targetKey) {
-      if (!clamping && repeat) return;
-      setKeyPressed(true);
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
     }
-  }, [clamping, targetKey]);
-  const upHandler = (0, _react.useCallback)(_ref2 => {
-    let {
-      key,
-      repeat
-    } = _ref2;
-    if (key === targetKey) {
-      if (!clamping && repeat) return;
-      setKeyPressed(false);
-    }
-  }, [clamping, targetKey]);
-  (0, _react.useEffect)(() => {
-    const handleDown = event => downHandler(event);
-    const handleUp = event => upHandler(event);
-    window.addEventListener("keydown", handleDown);
-    window.addEventListener("keyup", handleUp);
-    return () => {
-      window.removeEventListener("keydown", handleDown);
-      window.removeEventListener("keyup", handleUp);
-    };
-  }, [downHandler, upHandler]);
-  return keyPressed;
-};
-var _default = exports.default = useKeyPress;
+});
+const _react = require("react");
+/**
+ * A hook that detects when a specific key is pressed
+ * @param targetKey - The key to listen for
+ * @param clamping - Whether to allow key repeat events
+ * @returns boolean indicating if the target key is currently pressed
+ */ function useKeyPress(targetKey, clamping = true) {
+    const [keyPressed, setKeyPressed] = (0, _react.useState)(false);
+    const downHandler = (0, _react.useCallback)(({ key, repeat })=>{
+        if (key === targetKey) {
+            if (!clamping && repeat) return;
+            setKeyPressed(true);
+        }
+    }, [
+        clamping,
+        targetKey
+    ]);
+    const upHandler = (0, _react.useCallback)(({ key, repeat })=>{
+        if (key === targetKey) {
+            if (!clamping && repeat) return;
+            setKeyPressed(false);
+        }
+    }, [
+        clamping,
+        targetKey
+    ]);
+    (0, _react.useEffect)(()=>{
+        const handleDown = (event)=>downHandler(event);
+        const handleUp = (event)=>upHandler(event);
+        window.addEventListener('keydown', handleDown);
+        window.addEventListener('keyup', handleUp);
+        return ()=>{
+            window.removeEventListener('keydown', handleDown);
+            window.removeEventListener('keyup', handleUp);
+        };
+    }, [
+        downHandler,
+        upHandler
+    ]);
+    return keyPressed;
+}
+const _default = useKeyPress;