intelicoreact 1.5.32 → 1.5.34

package/dist/src/Atomic/UI/Modal/partials/ModalFooter.test.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _react1 = require("@testing-library/react");
+const _ModalFooter = /*#__PURE__*/ _interop_require_default(require("./ModalFooter"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+describe('modalFooter', ()=>{
+    const defaultProps = {
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+            children: "Test Content"
+        }),
+        testId: 'test-footer'
+    };
+    it('renders correctly with default props', ()=>{
+        (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+            ...defaultProps
+        }));
+        const footer = _react1.screen.getByTestId('test-footer');
+        expect(footer).toBeInTheDocument();
+        expect(footer).toHaveClass('modal__footer');
+    });
+    it('renders children correctly', ()=>{
+        const testContent = 'Test Footer Content';
+        (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+            ...defaultProps,
+            children: testContent
+        }));
+        expect(_react1.screen.getByText(testContent)).toBeInTheDocument();
+    });
+    it('applies custom className', ()=>{
+        const customClass = 'custom-class';
+        (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+            ...defaultProps,
+            className: customClass
+        }));
+        const footer = _react1.screen.getByTestId('test-footer');
+        expect(footer).toHaveClass('modal__footer', customClass);
+    });
+    it('uses wrapperRef correctly', ()=>{
+        var _ref_current;
+        const ref = /*#__PURE__*/ _react.default.createRef();
+        // @ts-ignore
+        (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+            ...defaultProps,
+            wrapperRef: ref
+        }));
+        expect(ref.current).toBeInstanceOf(HTMLElement);
+        expect((_ref_current = ref.current) === null || _ref_current === void 0 ? void 0 : _ref_current.tagName).toBe('FOOTER');
+    });
+    describe('accessibility', ()=>{
+        it('has correct ARIA attributes', ()=>{
+            (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+                ...defaultProps
+            }));
+            const footer = _react1.screen.getByRole('contentinfo');
+            expect(footer).toHaveAttribute('aria-label', 'Modal footer');
+        });
+        it('has correct semantic HTML structure', ()=>{
+            (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+                ...defaultProps
+            }));
+            expect(_react1.screen.getByRole('contentinfo')).toBeInTheDocument();
+        });
+        it('maintains content structure', ()=>{
+            const complexContent = /*#__PURE__*/ (0, _jsxruntime.jsxs)("div", {
+                role: "group",
+                "aria-label": "Footer actions",
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)("button", {
+                        children: "Cancel"
+                    }),
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)("button", {
+                        children: "Confirm"
+                    })
+                ]
+            });
+            (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+                children: complexContent
+            }));
+            const group = _react1.screen.getByRole('group');
+            expect(group).toHaveAttribute('aria-label', 'Footer actions');
+            expect(_react1.screen.getAllByRole('button')).toHaveLength(2);
+        });
+    });
+    describe('memoization', ()=>{
+        it('should not re-render with same props', ()=>{
+            const { rerender } = (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+                ...defaultProps
+            }));
+            const firstRender = _react1.screen.getByTestId('test-footer');
+            rerender(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+                ...defaultProps
+            }));
+            const secondRender = _react1.screen.getByTestId('test-footer');
+            expect(firstRender).toBe(secondRender);
+        });
+        it('should re-render with different props', ()=>{
+            const { rerender } = (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+                ...defaultProps,
+                className: "initial"
+            }));
+            const initialClassName = _react1.screen.getByTestId('test-footer').className;
+            rerender(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalFooter.default, {
+                ...defaultProps,
+                className: "updated"
+            }));
+            const updatedClassName = _react1.screen.getByTestId('test-footer').className;
+            expect(initialClassName).not.toBe(updatedClassName);
+        });
+    });
+});

package/dist/src/Atomic/UI/Modal/partials/ModalTitle.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _classnames = /*#__PURE__*/ _interop_require_default(require("classnames"));
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactfeather = require("react-feather");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 ModalTitle = /*#__PURE__*/ (0, _react.memo)(({ variant = 'primary', children, isForced = false, onClose, noHeaderCloseBtn = false, className, wrapperRef, testId = 'modal-title' })=>{
+    const handleKeyDown = (0, _react.useCallback)((e)=>{
+        if (e.key === 'Enter' || e.key === 'Space') {
+            e.preventDefault();
+            onClose === null || onClose === void 0 ? void 0 : onClose();
+        }
+    }, [
+        onClose
+    ]);
+    const handleClick = (0, _react.useCallback)(()=>{
+        onClose === null || onClose === void 0 ? void 0 : onClose();
+    }, [
+        onClose
+    ]);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)("header", {
+        "data-testid": testId,
+        ref: wrapperRef,
+        className: (0, _classnames.default)('modal__header', className, {
+            [`modal__header-${variant}`]: variant
+        }),
+        role: "banner",
+        "aria-label": "Modal header",
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)("span", {
+                className: (0, _classnames.default)('modal__header-title', {
+                    [`modal__header-${variant}-title`]: variant
+                }),
+                id: `${testId}-heading`,
+                children: children
+            }),
+            !isForced && /*#__PURE__*/ (0, _jsxruntime.jsx)("button", {
+                type: "button",
+                onClick: handleClick,
+                onKeyDown: handleKeyDown,
+                className: (0, _classnames.default)('modal-close-icon-box', {
+                    'modal-close-icon-box-primary': variant === 'primary'
+                }),
+                "aria-label": "Close modal",
+                title: "Close modal",
+                children: !noHeaderCloseBtn && /*#__PURE__*/ (0, _jsxruntime.jsx)(_reactfeather.X, {
+                    className: "modal-close-icon",
+                    role: "img",
+                    "aria-hidden": "true"
+                })
+            })
+        ]
+    });
+});
+ModalTitle.displayName = 'ModalTitle';
+const _default = ModalTitle;

package/dist/src/Atomic/UI/Modal/partials/ModalTitle.test.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _react1 = require("@testing-library/react");
+const _userevent = /*#__PURE__*/ _interop_require_default(require("@testing-library/user-event"));
+const _ModalTitle = /*#__PURE__*/ _interop_require_default(require("./ModalTitle"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+describe('modalTitle', ()=>{
+    const defaultProps = {
+        children: 'Test Title',
+        onClose: jest.fn(),
+        testId: 'test-modal'
+    };
+    beforeEach(()=>{
+        jest.clearAllMocks();
+    });
+    it('renders correctly with default props', ()=>{
+        (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+            ...defaultProps
+        }));
+        const header = _react1.screen.getByRole('banner');
+        const closeButton = _react1.screen.getByRole('button');
+        expect(header).toHaveClass('modal__header', 'modal__header-primary');
+        expect(closeButton).toBeInTheDocument();
+    });
+    it('applies custom className', ()=>{
+        (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+            ...defaultProps,
+            className: "custom-class"
+        }));
+        expect(_react1.screen.getByRole('banner')).toHaveClass('custom-class');
+    });
+    it('handles different variants', ()=>{
+        const { rerender } = (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+            ...defaultProps,
+            variant: "default"
+        }));
+        rerender(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+            ...defaultProps,
+            variant: "default"
+        }));
+        expect(_react1.screen.getByRole('banner')).toHaveClass('modal__header-default');
+    });
+    describe('close button', ()=>{
+        it('calls onClose when clicked', async ()=>{
+            const onClose = jest.fn();
+            (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+                ...defaultProps,
+                onClose: onClose
+            }));
+            await _userevent.default.click(_react1.screen.getByRole('button'));
+            expect(onClose).toHaveBeenCalledTimes(1);
+        });
+        it('handles keyboard events correctly', ()=>{
+            const onClose = jest.fn();
+            (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+                ...defaultProps,
+                onClose: onClose
+            }));
+            const button = _react1.screen.getByRole('button');
+            // Проверяем нажатие Enter
+            _react1.fireEvent.keyDown(button, {
+                key: 'Enter'
+            });
+            expect(onClose).toHaveBeenCalledTimes(1);
+            // Сбрасываем моковую функцию
+            onClose.mockClear();
+            // Проверяем нажатие Space
+            _react1.fireEvent.keyDown(button, {
+                key: 'Space'
+            });
+            expect(onClose).toHaveBeenCalledTimes(1);
+        });
+        it('is not rendered when isForced is true', ()=>{
+            (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+                ...defaultProps,
+                isForced: true
+            }));
+            expect(_react1.screen.queryByRole('button')).not.toBeInTheDocument();
+        });
+        it('renders without icon when noHeaderCloseBtn is true', ()=>{
+            (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+                ...defaultProps,
+                noHeaderCloseBtn: true
+            }));
+            const button = _react1.screen.getByRole('button');
+            expect(button).toBeInTheDocument();
+            expect(button.querySelector('.modal-close-icon')).not.toBeInTheDocument();
+        });
+    });
+    describe('accessibility', ()=>{
+        it('has correct ARIA attributes', ()=>{
+            (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+                ...defaultProps
+            }));
+            const header = _react1.screen.getByRole('banner');
+            const closeButton = _react1.screen.getByRole('button');
+            expect(header).toHaveAttribute('aria-label', 'Modal header');
+            expect(closeButton).toHaveAttribute('aria-label', 'Close modal');
+        });
+        it('makes close icon decorative', ()=>{
+            (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+                ...defaultProps
+            }));
+            const icon = _react1.screen.getByRole('img', {
+                hidden: true
+            });
+            expect(icon).toHaveAttribute('aria-hidden', 'true');
+        });
+    });
+    it('uses wrapperRef correctly', ()=>{
+        const ref = /*#__PURE__*/ _react.default.createRef();
+        (0, _react1.render)(/*#__PURE__*/ (0, _jsxruntime.jsx)(_ModalTitle.default, {
+            ...defaultProps,
+            wrapperRef: ref
+        }));
+        expect(ref.current).toBeInstanceOf(HTMLElement);
+    });
+});

package/dist/src/Atomic/UI/Modal/partials/useMobileModal.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return useMobileModal;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = require("react");
+const _useIsMobile = /*#__PURE__*/ _interop_require_default(require("../../../../Functions/useIsMobile/useIsMobile"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const SCROLL_DIRECTION = {
+    UP: 'up',
+    DOWN: 'down'
+};
+function useMobileModal({ withMobileLogic = false, withFixedFooter = false, isOpen = false }) {
+    const modalMobileContainerRef = (0, _react.useRef)(null);
+    const modalMobileHeaderRef = (0, _react.useRef)(null);
+    const modalMobileFooterRef = (0, _react.useRef)(null);
+    const modalMobileBodyRef = (0, _react.useRef)(null);
+    const { isMobile } = (0, _useIsMobile.default)();
+    const [scrollTop, setScrollTop] = (0, _react.useState)(0);
+    const [scrollHeight, setScrollHeight] = (0, _react.useState)(1);
+    const [modalsLogic, setModalsLogic] = (0, _react.useState)({
+        IS_HEADER_HIDDEN: false,
+        IS_HEADER_STICKY: false,
+        IS_FOOTER_HIDDEN: false,
+        IS_FOOTER_STICKY: withFixedFooter
+    });
+    // Update scroll state
+    const updateScrollState = (0, _react.useCallback)(()=>{
+        var _modalMobileHeaderRef_current, _modalMobileFooterRef_current;
+        const container = modalMobileContainerRef.current;
+        if (!container || !isOpen) return;
+        const currentScrollTop = container.scrollTop;
+        var _modalMobileHeaderRef_current_offsetHeight;
+        const headerHeight = (_modalMobileHeaderRef_current_offsetHeight = (_modalMobileHeaderRef_current = modalMobileHeaderRef.current) === null || _modalMobileHeaderRef_current === void 0 ? void 0 : _modalMobileHeaderRef_current.offsetHeight) !== null && _modalMobileHeaderRef_current_offsetHeight !== void 0 ? _modalMobileHeaderRef_current_offsetHeight : 0;
+        var _modalMobileFooterRef_current_offsetHeight;
+        const footerHeight = (_modalMobileFooterRef_current_offsetHeight = (_modalMobileFooterRef_current = modalMobileFooterRef.current) === null || _modalMobileFooterRef_current === void 0 ? void 0 : _modalMobileFooterRef_current.offsetHeight) !== null && _modalMobileFooterRef_current_offsetHeight !== void 0 ? _modalMobileFooterRef_current_offsetHeight : 0;
+        const containerHeight = container.scrollHeight;
+        const viewportHeight = window.innerHeight;
+        const maxScroll = Math.max(0, containerHeight - viewportHeight);
+        setScrollTop(currentScrollTop);
+        setScrollHeight(maxScroll);
+        setModalsLogic((prev)=>({
+                ...prev,
+                IS_HEADER_HIDDEN: currentScrollTop > 0,
+                IS_HEADER_STICKY: currentScrollTop >= headerHeight,
+                IS_FOOTER_HIDDEN: !withFixedFooter && currentScrollTop >= maxScroll - footerHeight,
+                IS_FOOTER_STICKY: withFixedFooter
+            }));
+    }, [
+        isOpen,
+        withFixedFooter
+    ]);
+    // Handle scroll events
+    (0, _react.useEffect)(()=>{
+        const container = modalMobileContainerRef.current;
+        if (container && isOpen) {
+            container.addEventListener('scroll', updateScrollState, {
+                passive: true
+            });
+            updateScrollState(); // Initial state update
+        }
+        return ()=>{
+            if (container) {
+                container.removeEventListener('scroll', updateScrollState);
+            }
+        };
+    }, [
+        isOpen,
+        updateScrollState
+    ]);
+    // Handle resize events
+    (0, _react.useEffect)(()=>{
+        if (isOpen) {
+            window.addEventListener('resize', updateScrollState, {
+                passive: true
+            });
+        }
+        return ()=>{
+            window.removeEventListener('resize', updateScrollState);
+        };
+    }, [
+        isOpen,
+        updateScrollState
+    ]);
+    // Initial setup when modal opens
+    (0, _react.useEffect)(()=>{
+        if (isOpen) {
+            updateScrollState();
+        }
+    }, [
+        isOpen,
+        updateScrollState
+    ]);
+    // Update footer sticky state
+    (0, _react.useEffect)(()=>{
+        setModalsLogic((prev)=>({
+                ...prev,
+                IS_FOOTER_STICKY: withFixedFooter
+            }));
+    }, [
+        withFixedFooter
+    ]);
+    const renderModal = (0, _react.useCallback)((modal)=>{
+        if (!isMobile || !withMobileLogic) return modal;
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+            className: "modal-mobile-container",
+            ref: modalMobileContainerRef,
+            children: modal
+        });
+    }, [
+        isMobile,
+        withMobileLogic
+    ]);
+    return {
+        modalMobileContainerRef,
+        modalMobileHeaderRef,
+        modalMobileBodyRef,
+        modalMobileFooterRef,
+        MODALS_LOGIC: modalsLogic,
+        SCROLL_DIRECTION,
+        scrollTop,
+        scrollHeight,
+        renderModal,
+        isMobile
+    };
+}

package/dist/src/Atomic/UI/Modal/partials/useMobileModal.test.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = require("@testing-library/react");
+const _useIsMobile = /*#__PURE__*/ _interop_require_default(require("../../../../Functions/useIsMobile"));
+const _useMobileModal = /*#__PURE__*/ _interop_require_default(require("./useMobileModal"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+jest.mock('../../../../Functions/useIsMobile', ()=>({
+        __esModule: true,
+        default: jest.fn(()=>({
+                isMobile: true
+            }))
+    }));
+describe('useMobileModal', ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        _useIsMobile.default.mockImplementation(()=>({
+                isMobile: true
+            }));
+    });
+    it('should initialize with default values', ()=>{
+        const { result } = (0, _react.renderHook)(()=>(0, _useMobileModal.default)({
+                isOpen: false,
+                withMobileLogic: false
+            }));
+        expect(result.current.MODALS_LOGIC).toEqual({
+            IS_HEADER_HIDDEN: false,
+            IS_HEADER_STICKY: false,
+            IS_FOOTER_HIDDEN: false,
+            IS_FOOTER_STICKY: false
+        });
+        expect(result.current.scrollTop).toBe(0);
+        expect(result.current.scrollHeight).toBe(1);
+    });
+    it('should initialize with fixed footer when withFixedFooter is true', ()=>{
+        const { result } = (0, _react.renderHook)(()=>(0, _useMobileModal.default)({
+                isOpen: true,
+                withMobileLogic: true,
+                withFixedFooter: true
+            }));
+        expect(result.current.MODALS_LOGIC.IS_FOOTER_STICKY).toBe(true);
+    });
+    it('should provide all required refs', ()=>{
+        const { result } = (0, _react.renderHook)(()=>(0, _useMobileModal.default)({
+                isOpen: true,
+                withMobileLogic: true
+            }));
+        expect(result.current.modalMobileContainerRef).toBeDefined();
+        expect(result.current.modalMobileHeaderRef).toBeDefined();
+        expect(result.current.modalMobileBodyRef).toBeDefined();
+        expect(result.current.modalMobileFooterRef).toBeDefined();
+    });
+    it('should provide scroll directions', ()=>{
+        const { result } = (0, _react.renderHook)(()=>(0, _useMobileModal.default)({
+                isOpen: true,
+                withMobileLogic: true
+            }));
+        expect(result.current.SCROLL_DIRECTION).toEqual({
+            UP: 'up',
+            DOWN: 'down'
+        });
+    });
+    describe('renderModal', ()=>{
+        it('should return original content when not mobile', ()=>{
+            _useIsMobile.default.mockImplementation(()=>({
+                    isMobile: false
+                }));
+            const { result } = (0, _react.renderHook)(()=>(0, _useMobileModal.default)({
+                    isOpen: true,
+                    withMobileLogic: true
+                }));
+            const testContent = /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+                children: "Test Content"
+            });
+            const rendered = result.current.renderModal(testContent);
+            expect(rendered).toBe(testContent);
+        });
+        it('should return original content when withMobileLogic is false', ()=>{
+            const { result } = (0, _react.renderHook)(()=>(0, _useMobileModal.default)({
+                    isOpen: true,
+                    withMobileLogic: false
+                }));
+            const testContent = /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+                children: "Test Content"
+            });
+            const rendered = result.current.renderModal(testContent);
+            expect(rendered).toBe(testContent);
+        });
+        it('should return React element when mobile and withMobileLogic is true', ()=>{
+            const { result } = (0, _react.renderHook)(()=>(0, _useMobileModal.default)({
+                    isOpen: true,
+                    withMobileLogic: true
+                }));
+            const testContent = /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+                children: "Test Content"
+            });
+            const rendered = result.current.renderModal(testContent);
+            expect(React.isValidElement(rendered)).toBe(true);
+        });
+    });
+    describe('props handling', ()=>{
+        it('should handle undefined props', ()=>{
+            const { result } = (0, _react.renderHook)(()=>(0, _useMobileModal.default)({}));
+            expect(result.current.MODALS_LOGIC).toBeDefined();
+            expect(result.current.scrollTop).toBeDefined();
+            expect(result.current.scrollHeight).toBeDefined();
+        });
+        it('should handle all props as false', ()=>{
+            const { result } = (0, _react.renderHook)(()=>(0, _useMobileModal.default)({
+                    isOpen: false,
+                    withMobileLogic: false,
+                    withFixedFooter: false
+                }));
+            expect(result.current.MODALS_LOGIC.IS_FOOTER_STICKY).toBe(false);
+        });
+        it('should handle modalRef prop', ()=>{
+            const mockRef = {
+                current: null
+            };
+            const { result } = (0, _react.renderHook)(()=>(0, _useMobileModal.default)({
+                    // @ts-ignore
+                    modalRef: mockRef
+                }));
+            expect(result.current.modalMobileContainerRef).toBeDefined();
+        });
+    });
+});

package/dist/src/Atomic/UI/MonoAccordion/MonoAccordion.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});