@ozen-ui/kit 0.0.1

package/__inner__/esm/components/Typography/utils.js

@@ -0,0 +1,28 @@
+export var matchVariantToTag = {
+    'heading-4xl': 'h1',
+    'heading-3xl': 'h2',
+    'heading-2xl': 'h3',
+    'heading-xl': 'h4',
+    'text-4xl': 'p',
+    'text-4xl_1': 'p',
+    'text-3xl': 'p',
+    'text-3xl_1': 'p',
+    'text-2xl': 'p',
+    'text-2xl_1': 'p',
+    'text-xl': 'p',
+    'text-xl_1': 'p',
+    'text-l': 'p',
+    'text-l_1': 'p',
+    'text-m': 'p',
+    'text-m_1': 'p',
+    'text-s': 'p',
+    'text-s_1': 'p',
+    'text-xs': 'p',
+    'text-xs_1': 'p',
+    'text-2xs': 'p',
+    'text-2xs_1': 'p',
+    'text-3xs': 'p',
+    'text-3xs_1': 'p',
+    'caption-3xs': 'span',
+    'caption-3xs_1': 'span'
+};

package/__inner__/esm/hooks/useBoolean/index.d.ts

@@ -0,0 +1 @@
+export * from './useBoolean';

package/__inner__/esm/hooks/useBoolean/index.js

@@ -0,0 +1 @@
+export * from './useBoolean';

package/__inner__/esm/hooks/useBoolean/useBoolean.d.ts

@@ -0,0 +1,13 @@
+type UseBooleanControllers = {
+    /** Установить значение в {true} */
+    on: () => void;
+    /** Установить значение в {false} */
+    off: () => void;
+    /** Перевести значение в противоположное состояние */
+    toggle: () => void;
+};
+type UseBooleanReturnValue = [boolean, UseBooleanControllers];
+export declare function useBoolean(
+/** Значение по умолчанию */
+defaultValue?: boolean): UseBooleanReturnValue;
+export {};

package/__inner__/esm/hooks/useBoolean/useBoolean.js

@@ -0,0 +1,12 @@
+import { __read } from "tslib";
+import { useState } from 'react';
+export function useBoolean(
+/** Значение по умолчанию */
+defaultValue) {
+    if (defaultValue === void 0) { defaultValue = false; }
+    var _a = __read(useState(defaultValue), 2), value = _a[0], setValue = _a[1];
+    var on = function () { return setValue(true); };
+    var off = function () { return setValue(false); };
+    var toggle = function () { return setValue(function (value) { return !value; }); };
+    return [value, { on: on, off: off, toggle: toggle }];
+}

package/__inner__/esm/hooks/useBreakpoints/index.d.ts

@@ -0,0 +1 @@
+export * from './useBreakpoints';

package/__inner__/esm/hooks/useBreakpoints/index.js

@@ -0,0 +1 @@
+export * from './useBreakpoints';

package/__inner__/esm/hooks/useBreakpoints/useBreakpoints.d.ts

@@ -0,0 +1,4 @@
+import { type BreakpointVariant } from '../../types/Breakpoints';
+type BreakpointMatches = Record<BreakpointVariant, boolean>;
+export declare function useBreakpoints(): BreakpointMatches;
+export {};

package/__inner__/esm/hooks/useBreakpoints/useBreakpoints.js

@@ -0,0 +1,60 @@
+import { __assign, __read, __values } from "tslib";
+import { useState, useCallback, useDebugValue } from 'react';
+import { breakpointVariant, } from '../../types/Breakpoints';
+import { useIsomorphicEffect } from '../useIsomorphicEffect';
+var breakpoint = {
+    xs: '(min-width: 0px)',
+    s: '(min-width: 640px)',
+    m: '(min-width: 1024px)',
+    l: '(min-width: 1280px)'
+};
+export function useBreakpoints() {
+    var _a = __read(useState(breakpointVariant.reduce(function (acc, key) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[key] = window.matchMedia(breakpoint[key]).matches, _a)));
+    }, {})), 2), matches = _a[0], setMatches = _a[1];
+    var updateMatches = useCallback(function (key) { return function (e) {
+        setMatches(function (prevMatches) {
+            var _a;
+            return (__assign(__assign({}, prevMatches), (_a = {}, _a[key] = e.matches, _a)));
+        });
+    }; }, []);
+    useIsomorphicEffect(function () {
+        var e_1, _a;
+        var matchMedias = [];
+        try {
+            for (var breakpointVariant_1 = __values(breakpointVariant), breakpointVariant_1_1 = breakpointVariant_1.next(); !breakpointVariant_1_1.done; breakpointVariant_1_1 = breakpointVariant_1.next()) {
+                var key = breakpointVariant_1_1.value;
+                var matchMedia_1 = window.matchMedia(breakpoint[key]);
+                var func = updateMatches(key);
+                matchMedia_1.addEventListener('change', func);
+                matchMedias.push({ matchMedia: matchMedia_1, func: func });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (breakpointVariant_1_1 && !breakpointVariant_1_1.done && (_a = breakpointVariant_1["return"])) _a.call(breakpointVariant_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return function () {
+            var e_2, _a;
+            try {
+                for (var matchMedias_1 = __values(matchMedias), matchMedias_1_1 = matchMedias_1.next(); !matchMedias_1_1.done; matchMedias_1_1 = matchMedias_1.next()) {
+                    var _b = matchMedias_1_1.value, matchMedia_2 = _b.matchMedia, func = _b.func;
+                    matchMedia_2.removeEventListener('change', func);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (matchMedias_1_1 && !matchMedias_1_1.done && (_a = matchMedias_1["return"])) _a.call(matchMedias_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        };
+    }, []);
+    useDebugValue(matches);
+    return matches;
+}

package/__inner__/esm/hooks/useClickOutside/index.d.ts

@@ -0,0 +1 @@
+export * from './useClickOutside';

package/__inner__/esm/hooks/useClickOutside/index.js

@@ -0,0 +1 @@
+export * from './useClickOutside';

package/__inner__/esm/hooks/useClickOutside/useClickOutside.d.ts

@@ -0,0 +1,15 @@
+import type { RefObject } from 'react';
+export interface UseClickOutside {
+    /** Массив refs для которых необходимо игнорировать внешние клики */
+    refs?: ReadonlyArray<RefObject<HTMLElement>>;
+    /** Функция обратного вызова которая будет вызвана при внешнем клике */
+    handler?: () => void;
+    /** Событие клика */
+    eventName?: 'mousedown' | 'mouseup' | 'click';
+    /** вкл. / выкл */
+    active?: boolean;
+    /** Опции для метода addEventListener (третий аргумент) */
+    options?: AddEventListenerOptions;
+}
+/** Хук отслеживающий клики за пределами указанных dom-элементов */
+export declare function useClickOutside({ refs, handler, active, eventName, options, }: UseClickOutside): void;

package/__inner__/esm/hooks/useClickOutside/useClickOutside.js

@@ -0,0 +1,23 @@
+import { useRef, useEffect } from 'react';
+import { useEventListener } from '../useEventListener';
+/** Хук отслеживающий клики за пределами указанных dom-элементов */
+export function useClickOutside(_a) {
+    var refs = _a.refs, handler = _a.handler, _b = _a.active, active = _b === void 0 ? true : _b, _c = _a.eventName, eventName = _c === void 0 ? 'mousedown' : _c, options = _a.options;
+    var savedRefs = useRef(refs);
+    useEffect(function () {
+        savedRefs.current = refs;
+    }, [refs]);
+    useEventListener({
+        eventName: eventName,
+        handler: function (event) {
+            var _a;
+            var target = event.target;
+            var isClickOutsideRefs = (_a = savedRefs.current) === null || _a === void 0 ? void 0 : _a.every(function (ref) { var _a; return !((_a = ref.current) === null || _a === void 0 ? void 0 : _a.contains(target)); });
+            if (isClickOutsideRefs && handler) {
+                handler();
+            }
+        },
+        active: active,
+        options: options
+    });
+}

package/__inner__/esm/hooks/useControlled/index.d.ts

@@ -0,0 +1 @@
+export * from './useControlled';

package/__inner__/esm/hooks/useControlled/index.js

@@ -0,0 +1 @@
+export * from './useControlled';

package/__inner__/esm/hooks/useControlled/useControlled.d.ts

@@ -0,0 +1,16 @@
+export interface UseControlledProps<T = unknown> {
+    /** Значение */
+    value: T | undefined;
+    /** Дефолтное значение */
+    defaultValue: T | undefined;
+    /** Имя компонента для предупреждения */
+    name: string;
+    /** Имя свойства для предупреждения */
+    state?: string;
+}
+/**
+ * Управляет значением компонента
+ * при контролируемом и неконтролируемом
+ * поведении
+ * */
+export declare const useControlled: <T = unknown>({ value: valueProp, defaultValue: defaultProp, name, state, }: UseControlledProps<T>) => [T | undefined, (newValue: T) => void, boolean];

package/__inner__/esm/hooks/useControlled/useControlled.js

@@ -0,0 +1,45 @@
+import { __read } from "tslib";
+/* eslint-disable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */
+import { useState, useCallback, useEffect, useRef } from 'react';
+/**
+ * Управляет значением компонента
+ * при контролируемом и неконтролируемом
+ * поведении
+ * */
+export var useControlled = function (_a) {
+    var valueProp = _a.value, defaultProp = _a.defaultValue, name = _a.name, _b = _a.state, state = _b === void 0 ? 'value' : _b;
+    /**
+     * Определение контролируемого поведения
+     * при первом рендере
+     * (неизменяемое значение)
+     * */
+    var isControlled = useRef(valueProp !== undefined).current;
+    var _c = __read(useState(defaultProp), 2), valueState = _c[0], setValue = _c[1];
+    var value = isControlled ? valueProp : valueState;
+    if (process.env.NODE_ENV !== 'production') {
+        useEffect(function () {
+            if (isControlled !== (valueProp !== undefined)) {
+                console.error([
+                    "\u00D6zen-UI: \u041F\u043E\u0432\u0435\u0434\u0435\u043D\u0438\u0435 \u0441\u0432\u043E\u0439\u0441\u0442\u0432\u0430 '".concat(state, "' \u0443 \u043A\u043E\u043C\u043F\u043E\u043D\u0435\u043D\u0442\u0430 ").concat(name, " \u043F\u043E\u043C\u0435\u043D\u044F\u043B\u043E\u0441\u044C \u0441 ").concat(isControlled ? '' : 'не', "\u043A\u043E\u043D\u0442\u0440\u043E\u043B\u0438\u0440\u0443\u0435\u043C\u043E\u0433\u043E \u043D\u0430 ").concat(isControlled ? 'не' : '', "\u043A\u043E\u043D\u0442\u0440\u043E\u043B\u0438\u0440\u0443\u0435\u043C\u043E\u0435."),
+                    'Компоненты не должны переключаться с неконтролируемого поведения в контролируемое, или наоборот.',
+                    'Поведение определяется после первого рендера и является контролируемым, если значение не "undefined"',
+                ].join('\n'));
+            }
+        }, [state, name, valueProp]);
+        var defaultValue_1 = useRef(defaultProp).current;
+        useEffect(function () {
+            if (!isControlled && defaultValue_1 !== defaultProp) {
+                console.error([
+                    "\u00D6zen-UI: \u041D\u0435\u043A\u043E\u043D\u0442\u0440\u043E\u043B\u0438\u0440\u0443\u0435\u043C\u044B\u0439 \u043A\u043E\u043C\u043F\u043E\u043D\u0435\u043D\u0442 ".concat(name, " \u0441\u043C\u0435\u043D\u0438\u043B default ").concat(state, " \u043F\u043E\u0441\u043B\u0435 \u043F\u0435\u0440\u0432\u043E\u0439 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 ").concat(name) +
+                        "\u0415\u0441\u043B\u0438 \u043D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u043E \u043C\u0435\u043D\u044F\u0442\u044C \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0432\u043E\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435\u0441\u044C \u043A\u043E\u043D\u0442\u0440\u043E\u043B\u0438\u0440\u0443\u0435\u043C\u044B\u043C \u043F\u043E\u0432\u0435\u0434\u0435\u043D\u0438\u0435\u043C.",
+                ].join('\n'));
+            }
+        }, [JSON.stringify(defaultProp)]);
+    }
+    var setValueIfUncontrolled = useCallback(function (newValue) {
+        if (!isControlled) {
+            setValue(newValue);
+        }
+    }, []);
+    return [value, setValueIfUncontrolled, valueProp !== undefined];
+};

package/__inner__/esm/hooks/useCounter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useCounter';
+export * from './types';

package/__inner__/esm/hooks/useCounter/index.js

@@ -0,0 +1,2 @@
+export * from './useCounter';
+export * from './types';

package/__inner__/esm/hooks/useCounter/types.d.ts

@@ -0,0 +1,19 @@
+import type { Dispatch, SetStateAction } from 'react';
+export type UseCounterProps = {
+    /** Исходное значение счетчика */
+    initialValue?: number;
+    /** Размер шага инкрементации/декрементации значения */
+    step?: number;
+};
+export type UseCounterOutput = {
+    /** Текущее значение счетчика */
+    count: number;
+    /** Увеличить значение на заданный шаг */
+    increment: () => void;
+    /** Уменьшить значение на заданный шаг */
+    decrement: () => void;
+    /** Сбросить значение до исходного */
+    reset: () => void;
+    /** Функция обратного вызова для установки произвольного значения */
+    setCount: Dispatch<SetStateAction<number>>;
+};

package/__inner__/esm/hooks/useCounter/types.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/hooks/useCounter/useCounter.d.ts

@@ -0,0 +1,2 @@
+import type { UseCounterProps, UseCounterOutput } from './types';
+export declare function useCounter({ initialValue, step, }?: UseCounterProps): UseCounterOutput;

package/__inner__/esm/hooks/useCounter/useCounter.js

@@ -0,0 +1,16 @@
+import { __read } from "tslib";
+import { useState } from 'react';
+export function useCounter(_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.initialValue, initialValue = _c === void 0 ? 0 : _c, _d = _b.step, step = _d === void 0 ? 1 : _d;
+    var _e = __read(useState(initialValue), 2), count = _e[0], setCount = _e[1];
+    var increment = function () { return setCount(function (x) { return x + step; }); };
+    var decrement = function () { return setCount(function (x) { return x - step; }); };
+    var reset = function () { return setCount(initialValue); };
+    return {
+        count: count,
+        increment: increment,
+        decrement: decrement,
+        reset: reset,
+        setCount: setCount
+    };
+}

package/__inner__/esm/hooks/useDebounceCallback/index.d.ts

@@ -0,0 +1 @@
+export * from './useDebounceCallback';

package/__inner__/esm/hooks/useDebounceCallback/index.js

@@ -0,0 +1 @@
+export * from './useDebounceCallback';

package/__inner__/esm/hooks/useDebounceCallback/useDebounceCallback.d.ts

@@ -0,0 +1,12 @@
+type FunctionCallback = (...args: any[]) => void;
+export type UseDebounceCallbackReturnValue<CB extends FunctionCallback> = [
+    CB,
+    () => void
+];
+export interface DebounceOptions {
+    /** Первый вызов вызывается без задержки */
+    firstCallWithoutDelay: boolean;
+}
+/** Хук для задержки вызова функции */
+export declare function useDebounceCallback<CB extends FunctionCallback>(callback: CB, delay?: number, options?: DebounceOptions): UseDebounceCallbackReturnValue<CB>;
+export {};

package/__inner__/esm/hooks/useDebounceCallback/useDebounceCallback.js

@@ -0,0 +1,38 @@
+import { __read, __spreadArray } from "tslib";
+import { useCallback, useEffect, useRef } from 'react';
+/** Хук для задержки вызова функции */
+export function useDebounceCallback(callback, delay, options) {
+    if (delay === void 0) { delay = 300; }
+    if (options === void 0) { options = { firstCallWithoutDelay: false }; }
+    var firstCallWithoutDelay = options.firstCallWithoutDelay;
+    var timeoutRef = useRef(null);
+    var debouncedHandler = useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (!timeoutRef.current && firstCallWithoutDelay) {
+            callback.apply(void 0, __spreadArray([], __read(args), false));
+            timeoutRef.current = setTimeout(function () {
+                timeoutRef.current = null;
+            }, delay);
+            return;
+        }
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(function () {
+            callback.apply(void 0, __spreadArray([], __read(args), false));
+            timeoutRef.current = null;
+        }, delay);
+    }, [callback, delay, options.firstCallWithoutDelay]);
+    var cancel = useCallback(function () {
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+    }, []);
+    useEffect(function () { return function () { return cancel(); }; }, []);
+    return [debouncedHandler, cancel];
+}

package/__inner__/esm/hooks/useEventListener/index.d.ts

@@ -0,0 +1 @@
+export * from './useEventListener';

package/__inner__/esm/hooks/useEventListener/index.js

@@ -0,0 +1 @@
+export * from './useEventListener';

package/__inner__/esm/hooks/useEventListener/useEventListener.d.ts

@@ -0,0 +1,19 @@
+import type { RefObject } from 'react';
+type UseEventListener<T, K, P> = {
+    /** Имя события, например "click" */
+    eventName: T;
+    /** Функция-обработчик которая сработает, как только событие произойдет. */
+    handler: K;
+    /** Ссылка на элемент к которому будет привязано событие */
+    element?: P;
+    /** Дополнительный объект со свойствами */
+    options?: boolean | AddEventListenerOptions;
+    /** Признак активности обработчика события, используется для повышения производительности. */
+    active?: boolean;
+};
+export declare function useEventListener<K extends keyof MediaQueryListEventMap>({ eventName, handler, element, options, active, }: UseEventListener<K, (event: MediaQueryListEventMap[K]) => void, RefObject<MediaQueryList>>): void;
+export declare function useEventListener<K extends keyof WindowEventMap>({ eventName, handler, element, options, active, }: UseEventListener<K, (event: WindowEventMap[K]) => void, undefined>): void;
+export declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = HTMLDivElement>({ eventName, handler, element, options, active, }: UseEventListener<K, (event: HTMLElementEventMap[K]) => void, RefObject<T>>): void;
+export declare function useEventListener<K extends keyof DocumentEventMap>({ eventName, handler, element, options, active, }: UseEventListener<K, (event: DocumentEventMap[K]) => void, RefObject<Document>>): void;
+export declare function useEventListener({ eventName, handler, element, options, active, }: UseEventListener<string, (event: Event | CustomEvent) => void, RefObject<Document | HTMLElement | Window> | undefined>): void;
+export {};

package/__inner__/esm/hooks/useEventListener/useEventListener.js

@@ -0,0 +1,24 @@
+import { useRef, useEffect, useCallback } from 'react';
+/** Хук добавляющий обработчики событий и удаляющий их на выходе */
+export function useEventListener(_a) {
+    var eventName = _a.eventName, handler = _a.handler, element = _a.element, options = _a.options, _b = _a.active, active = _b === void 0 ? true : _b;
+    var savedListener = useRef();
+    useEffect(function () {
+        savedListener.current = handler;
+    }, [handler]);
+    var handleEventListener = useCallback(function (event) {
+        var _a;
+        (_a = savedListener.current) === null || _a === void 0 ? void 0 : _a.call(savedListener, event);
+    }, []);
+    useEffect(function () {
+        var _a;
+        if (!active) {
+            return undefined;
+        }
+        var targetElement = (_a = element === null || element === void 0 ? void 0 : element.current) !== null && _a !== void 0 ? _a : window;
+        targetElement === null || targetElement === void 0 ? void 0 : targetElement.addEventListener(eventName, handleEventListener, options);
+        return function () {
+            targetElement === null || targetElement === void 0 ? void 0 : targetElement.removeEventListener(eventName, handleEventListener, options);
+        };
+    }, [eventName, element, options, active]);
+}

package/__inner__/esm/hooks/useFocusList/index.d.ts

@@ -0,0 +1 @@
+export * from './useFocusList';

package/__inner__/esm/hooks/useFocusList/index.js

@@ -0,0 +1 @@
+export * from './useFocusList';

package/__inner__/esm/hooks/useFocusList/useFocusList.d.ts

@@ -0,0 +1,6 @@
+import type { KeyboardEvent } from 'react';
+export type FocusProps = {
+    'data-focus-list': string;
+    onKeyDown: (event: KeyboardEvent) => void;
+};
+export declare function useFocusList(): FocusProps;

package/__inner__/esm/hooks/useFocusList/useFocusList.js

@@ -0,0 +1,23 @@
+import { useCallback } from 'react';
+import { getNextIndex } from '../../utils/getNextIndex';
+import { getPrevIndex } from '../../utils/getPrevIndex';
+import { isKey } from '../../utils/isKey';
+import { useUniqueId } from '../useUniqueId';
+export function useFocusList() {
+    var name = useUniqueId();
+    var onKeyDown = useCallback(function (event) {
+        if (!isKey(event, 'ArrowUp') && !isKey(event, 'ArrowDown')) {
+            return;
+        }
+        event.preventDefault();
+        var items = document.querySelectorAll("[data-focus-list=\"".concat(name, "\"]"));
+        var currentEl = event.target;
+        var currentIndex = Array.from(items).indexOf(currentEl);
+        var newIndex = isKey(event, 'ArrowUp')
+            ? getPrevIndex(currentIndex, items.length)
+            : getNextIndex(currentIndex, items.length);
+        var newEl = items.item(newIndex);
+        newEl.focus();
+    }, []);
+    return { 'data-focus-list': name, onKeyDown: onKeyDown };
+}

package/__inner__/esm/hooks/useFocusTrap/index.d.ts

@@ -0,0 +1 @@
+export * from './useFocusTrap';

package/__inner__/esm/hooks/useFocusTrap/index.js

@@ -0,0 +1 @@
+export * from './useFocusTrap';

package/__inner__/esm/hooks/useFocusTrap/useFocusTrap.d.ts

@@ -0,0 +1,14 @@
+import type { MutableRefObject, Ref } from 'react';
+export type UseFocusTrap = {
+    active?: boolean;
+    focusinTrap?: boolean;
+    keyDownTrap?: boolean;
+};
+/** Хук для ловушки фокуса, обычно применяется в контексте модальных окон */
+export declare function useFocusTrap<T>({ 
+/** Признак активности ловушки */
+active, 
+/** Предотвращает любые события фокуса вне контейнера ловушки */
+focusinTrap, 
+/** Предотвращает переход на элементы вне контейнера ловушки через клавиши {Tab} и {Tab + Shift} */
+keyDownTrap, }?: UseFocusTrap): MutableRefObject<T> | Ref<T>;

package/__inner__/esm/hooks/useFocusTrap/useFocusTrap.js

@@ -0,0 +1,67 @@
+import { useRef } from 'react';
+import { getFocusableElements } from '../../utils/getFocusableElements';
+import { isKey } from '../../utils/isKey';
+import { useEventListener } from '../useEventListener';
+/** Хук для ловушки фокуса, обычно применяется в контексте модальных окон */
+export function useFocusTrap(_a) {
+    var _b = _a === void 0 ? {
+        active: true,
+        focusinTrap: true,
+        keyDownTrap: true
+    } : _a, 
+    /** Признак активности ловушки */
+    _c = _b.active, 
+    /** Признак активности ловушки */
+    active = _c === void 0 ? true : _c, 
+    /** Предотвращает любые события фокуса вне контейнера ловушки */
+    focusinTrap = _b.focusinTrap, 
+    /** Предотвращает переход на элементы вне контейнера ловушки через клавиши {Tab} и {Tab + Shift} */
+    keyDownTrap = _b.keyDownTrap;
+    var elRef = useRef(null);
+    useEventListener({
+        eventName: 'focusin',
+        handler: function () {
+            var _a, _b;
+            if (!(elRef === null || elRef === void 0 ? void 0 : elRef.current)) {
+                return;
+            }
+            var keyboardFocusableElements = getFocusableElements(elRef.current);
+            if (!((_a = elRef.current) === null || _a === void 0 ? void 0 : _a.contains(document.activeElement))) {
+                var firstEl = keyboardFocusableElements[0];
+                if (firstEl) {
+                    firstEl.focus();
+                }
+                else {
+                    (_b = elRef.current) === null || _b === void 0 ? void 0 : _b.focus();
+                }
+            }
+        },
+        active: active && focusinTrap
+    });
+    useEventListener({
+        eventName: 'keydown',
+        handler: function (event) {
+            var _a, _b;
+            var shiftKey = event.shiftKey;
+            if (!(elRef === null || elRef === void 0 ? void 0 : elRef.current)) {
+                return;
+            }
+            var active = document.activeElement;
+            var focusable = getFocusableElements(elRef.current);
+            var last = focusable[focusable.length - 1];
+            if (shiftKey && isKey(event, 'Tab')) {
+                event.preventDefault();
+                var prev = (_a = focusable[(focusable.indexOf(active) - 1) % focusable.length]) !== null && _a !== void 0 ? _a : last;
+                prev === null || prev === void 0 ? void 0 : prev.focus();
+            }
+            else if (isKey(event, 'Tab')) {
+                if (focusable.indexOf(active) < 0 || active === last) {
+                    event.preventDefault();
+                    (_b = focusable[0]) === null || _b === void 0 ? void 0 : _b.focus();
+                }
+            }
+        },
+        active: active && keyDownTrap
+    });
+    return elRef;
+}

package/__inner__/esm/hooks/useInterval/index.d.ts

@@ -0,0 +1 @@
+export * from './useInterval';

package/__inner__/esm/hooks/useInterval/index.js

@@ -0,0 +1 @@
+export * from './useInterval';

package/__inner__/esm/hooks/useInterval/useInterval.d.ts

@@ -0,0 +1,5 @@
+export declare function useInterval(
+/** Функция обратного вызова которая будет срабатывать по заданному интервалу */
+callback: () => void, 
+/** Интервал времени в миллисекундах */
+interval: number | null): void;

package/__inner__/esm/hooks/useInterval/useInterval.js

@@ -0,0 +1,20 @@
+import { useEffect, useRef } from 'react';
+export function useInterval(
+/** Функция обратного вызова которая будет срабатывать по заданному интервалу */
+callback, 
+/** Интервал времени в миллисекундах */
+interval) {
+    var savedCallback = useRef(callback);
+    useEffect(function () {
+        savedCallback.current = callback;
+    }, [callback]);
+    useEffect(function () {
+        var intervalId;
+        if (interval || interval === 0) {
+            intervalId = setInterval(function () { return savedCallback.current(); }, interval);
+        }
+        return function () {
+            clearInterval(intervalId);
+        };
+    }, [interval]);
+}

package/__inner__/esm/hooks/useIsomorphicEffect/index.d.ts

@@ -0,0 +1 @@
+export * from './useIsomorphicEffect';

package/__inner__/esm/hooks/useIsomorphicEffect/index.js

@@ -0,0 +1 @@
+export * from './useIsomorphicEffect';

package/__inner__/esm/hooks/useIsomorphicEffect/useIsomorphicEffect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from 'react';
+export declare const useIsomorphicEffect: typeof useEffect;

package/__inner__/esm/hooks/useIsomorphicEffect/useIsomorphicEffect.js

@@ -0,0 +1,2 @@
+import { useEffect, useLayoutEffect } from 'react';
+export var useIsomorphicEffect = typeof window === 'undefined' ? useEffect : useLayoutEffect;

package/__inner__/esm/hooks/useMultiRef/index.d.ts

@@ -0,0 +1 @@
+export * from './useMultiRef';

package/__inner__/esm/hooks/useMultiRef/index.js

@@ -0,0 +1 @@
+export * from './useMultiRef';

package/__inner__/esm/hooks/useMultiRef/useMultiRef.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import type { Dispatch, SetStateAction, RefCallback } from 'react';
+type Ref<T> = React.Ref<T> | Dispatch<SetStateAction<T | undefined>> | null;
+/** Создает несколько ссылок (ref) на один DOM-элемент. */
+export declare function useMultiRef<T>(refs: Array<Ref<T> | undefined>): RefCallback<T> | null;
+export {};