@cloud-ru/ds-utils 1.0.0

package/dist/cjs/utils/keyboard.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERTICAL_ARROW_KEYS = exports.ARROW_KEYS = void 0;
+exports.isArrowKey = isArrowKey;
+exports.isVerticalArrowKey = isVerticalArrowKey;
+exports.preventScrollOnArrowKeys = preventScrollOnArrowKeys;
+exports.preventScrollOnVerticalArrows = preventScrollOnVerticalArrows;
+exports.focusWithoutScroll = focusWithoutScroll;
+/**
+ * Клавиши-стрелки. Внутри компонентов с собственной клавиатурной навигацией (списки, сетка
+ * календаря, roving-кнопки) их нативное поведение — прокрутка страницы — нужно гасить, иначе
+ * событие «улетает» за компонент и скроллит документ.
+ */
+exports.ARROW_KEYS = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'];
+/**
+ * Вертикальные стрелки. Для текстовых полей гасить нужно только их (горизонтальные `ArrowLeft` /
+ * `ArrowRight` двигают каретку — их перехватывать нельзя), тогда как в сетках/списках/roving-кнопках
+ * без текста гасятся все четыре (см. {@link ARROW_KEYS}).
+ */
+exports.VERTICAL_ARROW_KEYS = ['ArrowUp', 'ArrowDown'];
+/** `true`, если клавиша — одна из стрелок навигации. */
+function isArrowKey(key) {
+    return exports.ARROW_KEYS.includes(key);
+}
+/** `true`, если клавиша — вертикальная стрелка (`ArrowUp` / `ArrowDown`). */
+function isVerticalArrowKey(key) {
+    return exports.VERTICAL_ARROW_KEYS.includes(key);
+}
+/**
+ * Гасит нативную прокрутку страницы для клавиш-стрелок: если нажата стрелка — вызывает
+ * `preventDefault()` и возвращает `true`. Использовать в начале keydown-обработчика компонента,
+ * который сам обрабатывает стрелочную навигацию.
+ *
+ * @example
+ * const handleKeyDown = (e) => {
+ *   preventScrollOnArrowKeys(e);
+ *   // …собственная навигация
+ * };
+ */
+function preventScrollOnArrowKeys(event) {
+    if (isArrowKey(event.key)) {
+        event.preventDefault();
+        return true;
+    }
+    return false;
+}
+/**
+ * Как {@link preventScrollOnArrowKeys}, но только для вертикальных стрелок (`ArrowUp` / `ArrowDown`).
+ * Для текстовых полей: гасит прокрутку страницы по Up/Down, не трогая горизонтальные стрелки —
+ * каретка по тексту продолжает двигаться.
+ */
+function preventScrollOnVerticalArrows(event) {
+    if (isVerticalArrowKey(event.key)) {
+        event.preventDefault();
+        return true;
+    }
+    return false;
+}
+/**
+ * Программный фокус без авто-прокрутки страницы к элементу (`focus({ preventScroll: true })`).
+ * Применять при перемещении фокуса по клавиатуре внутри уже видимого компонента (ячейка
+ * календаря, элемент списка), иначе браузер скроллит документ к новому фокусу.
+ */
+function focusWithoutScroll(element) {
+    element?.focus({ preventScroll: true });
+}

package/dist/cjs/utils/preventEvent.d.ts

@@ -0,0 +1,4 @@
+import { KeyboardEvent, MouseEvent } from 'react';
+export declare function stopEventPropagation(event: MouseEvent<HTMLElement> | KeyboardEvent<HTMLElement>): void;
+export declare function preventEventDefault(event: MouseEvent<HTMLElement> | KeyboardEvent<HTMLElement>): void;
+export declare function preventEventDefaultAndPropagation(event: MouseEvent<HTMLElement> | KeyboardEvent<HTMLElement>): void;

package/dist/cjs/utils/preventEvent.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopEventPropagation = stopEventPropagation;
+exports.preventEventDefault = preventEventDefault;
+exports.preventEventDefaultAndPropagation = preventEventDefaultAndPropagation;
+function stopEventPropagation(event) {
+    event.stopPropagation();
+}
+function preventEventDefault(event) {
+    event.preventDefault();
+}
+function preventEventDefaultAndPropagation(event) {
+    stopEventPropagation(event);
+    preventEventDefault(event);
+}

package/dist/cjs/utils/stopEventPropagation.d.ts

@@ -0,0 +1,2 @@
+import { KeyboardEvent, MouseEvent } from 'react';
+export declare function stopEventPropagation(event: MouseEvent<HTMLElement> | KeyboardEvent<HTMLElement>): void;

package/dist/cjs/utils/stopEventPropagation.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopEventPropagation = stopEventPropagation;
+function stopEventPropagation(event) {
+    event.stopPropagation();
+}

package/dist/cjs/utils/throttle.d.ts

@@ -0,0 +1,11 @@
+/** Функция-обёртка `throttle`: вызывается как исходная, плюс умеет отменить отложенный вызов. */
+export type Throttled<TArgs extends unknown[]> = {
+    (...args: TArgs): void;
+    /** Отменяет запланированный вызов по заднему фронту. */
+    cancel(): void;
+};
+/**
+ * Ограничивает частоту вызовов `callback` до одного раза в `wait` мс.
+ * Срабатывает по обоим фронтам: первый вызов проходит сразу, последний в окне — по его истечении.
+ */
+export declare function throttle<TArgs extends unknown[]>(callback: (...args: TArgs) => void, wait?: number): Throttled<TArgs>;

package/dist/cjs/utils/throttle.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttle = throttle;
+/**
+ * Ограничивает частоту вызовов `callback` до одного раза в `wait` мс.
+ * Срабатывает по обоим фронтам: первый вызов проходит сразу, последний в окне — по его истечении.
+ */
+function throttle(callback, wait = 0) {
+    let lastInvokeTime = 0;
+    let timer;
+    let pendingArgs;
+    const invoke = (args) => {
+        lastInvokeTime = Date.now();
+        callback(...args);
+    };
+    const cancel = () => {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        pendingArgs = undefined;
+    };
+    const throttled = (...args) => {
+        const remaining = wait - (Date.now() - lastInvokeTime);
+        if (remaining <= 0) {
+            cancel();
+            invoke(args);
+            return;
+        }
+        pendingArgs = args;
+        if (timer === undefined) {
+            timer = setTimeout(() => {
+                timer = undefined;
+                if (pendingArgs !== undefined) {
+                    const args = pendingArgs;
+                    pendingArgs = undefined;
+                    invoke(args);
+                }
+            }, remaining);
+        }
+    };
+    return Object.assign(throttled, { cancel });
+}

package/dist/cjs/utils/typeGuards.d.ts

@@ -0,0 +1,5 @@
+export declare const isNil: (value: unknown) => value is undefined | null;
+export declare const isBoolean: (value: unknown) => value is boolean;
+export declare const isString: (value: unknown) => value is string;
+export declare const isArray: <T>(value: unknown) => value is Array<T>;
+export declare const isObject: (value: unknown) => value is object;

package/dist/cjs/utils/typeGuards.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = exports.isArray = exports.isString = exports.isBoolean = exports.isNil = void 0;
+const isNil = (value) => value === undefined || value === null;
+exports.isNil = isNil;
+const isBoolean = (value) => typeof value === 'boolean';
+exports.isBoolean = isBoolean;
+const isString = (value) => typeof value === 'string';
+exports.isString = isString;
+const isArray = (value) => Array.isArray(value);
+exports.isArray = isArray;
+const isObject = (value) => typeof value === 'object' && !(0, exports.isArray)(value);
+exports.isObject = isObject;

package/dist/esm/hooks/index.d.ts

@@ -0,0 +1,13 @@
+export * from './useDebounce.js';
+export * from './useDynamicList.js';
+export * from './useEventHandler.js';
+export * from './useHierarchicalSelection.js';
+export * from './useIsomorphicLayoutEffect.js';
+export * from './useSwipeable.js';
+export * from './useUncontrolledProp.js';
+export * from './useValueControl.js';
+export * from './useDataPersist/index.js';
+export * from './usePopstateSubscription.js';
+export * from './useModalOpenState.js';
+export * from './useCopyToClipboard.js';
+export * from './useLocalStorage.js';

package/dist/esm/hooks/index.js

@@ -0,0 +1,13 @@
+export * from './useDebounce.js';
+export * from './useDynamicList.js';
+export * from './useEventHandler.js';
+export * from './useHierarchicalSelection.js';
+export * from './useIsomorphicLayoutEffect.js';
+export * from './useSwipeable.js';
+export * from './useUncontrolledProp.js';
+export * from './useValueControl.js';
+export * from './useDataPersist/index.js';
+export * from './usePopstateSubscription.js';
+export * from './useModalOpenState.js';
+export * from './useCopyToClipboard.js';
+export * from './useLocalStorage.js';

package/dist/esm/hooks/useCopyToClipboard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Хук для копирования значения в буфер обмена и визуального подтверждения действия.
+ * @function React hook
+ * @param durationMs - Продолжительность отображения иконки подтверждения в миллисекундах. По-умолчанию 1000 мс.
+ */
+export declare function useCopyToClipboard(durationMs?: number): {
+    isChecked: boolean;
+    copy: (value: string) => void;
+};

package/dist/esm/hooks/useCopyToClipboard.js

@@ -0,0 +1,24 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { copyToClipboard } from '../utils/copyToClipboard.js';
+const DEFAULT_CHECKED_DURATION_MS = 1000;
+/**
+ * Хук для копирования значения в буфер обмена и визуального подтверждения действия.
+ * @function React hook
+ * @param durationMs - Продолжительность отображения иконки подтверждения в миллисекундах. По-умолчанию 1000 мс.
+ */
+export function useCopyToClipboard(durationMs = DEFAULT_CHECKED_DURATION_MS) {
+    const [isChecked, setIsChecked] = useState(false);
+    const timerRef = useRef();
+    const copy = useCallback((value) => {
+        if (!value)
+            return;
+        copyToClipboard(value).catch(() => undefined);
+        setIsChecked(true);
+        clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => setIsChecked(false), durationMs);
+    }, [durationMs]);
+    useEffect(() => () => {
+        clearTimeout(timerRef.current);
+    }, []);
+    return { isChecked, copy };
+}

package/dist/esm/hooks/useDataPersist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useDataPersist.js';
+export * from './sources/index.js';

package/dist/esm/hooks/useDataPersist/index.js

@@ -0,0 +1,2 @@
+export * from './useDataPersist.js';
+export * from './sources/index.js';

package/dist/esm/hooks/useDataPersist/sources/baseSource.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class BaseSource<TData> {
+    filterKey: string;
+    private validate;
+    protected parser: (value: string) => TData;
+    protected serializer: (value: TData) => string;
+    protected abstract getFromSource(): string;
+    protected abstract setToSource(value: string): void;
+    constructor(filterKey: string, validate: (value: unknown) => value is TData, parser?: (value: string) => TData, serializer?: (value: TData) => string);
+    getData: () => TData | null;
+    setData: (filter: TData) => void;
+}

package/dist/esm/hooks/useDataPersist/sources/baseSource.js

@@ -0,0 +1,31 @@
+export class BaseSource {
+    filterKey;
+    validate;
+    parser = JSON.parse;
+    serializer = JSON.stringify;
+    constructor(filterKey, validate, parser, serializer) {
+        this.filterKey = filterKey;
+        this.validate = validate;
+        if (parser) {
+            this.parser = parser;
+        }
+        if (serializer) {
+            this.serializer = serializer;
+        }
+    }
+    getData = () => {
+        try {
+            const filterFromQueryParams = this.getFromSource();
+            const parsedValue = filterFromQueryParams ? this.parser(filterFromQueryParams) : null;
+            const isValid = parsedValue && this.validate(parsedValue);
+            return isValid ? parsedValue : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    setData = (filter) => {
+        const encodedValue = this.serializer(filter);
+        this.setToSource(encodedValue);
+    };
+}

package/dist/esm/hooks/useDataPersist/sources/index.d.ts

@@ -0,0 +1,3 @@
+export * from './queryParamSource.js';
+export * from './localStorageSource.js';
+export * from './baseSource.js';

package/dist/esm/hooks/useDataPersist/sources/index.js

@@ -0,0 +1,3 @@
+export * from './queryParamSource.js';
+export * from './localStorageSource.js';
+export * from './baseSource.js';

package/dist/esm/hooks/useDataPersist/sources/localStorageSource.d.ts

@@ -0,0 +1,5 @@
+import { BaseSource } from './baseSource.js';
+export declare class LocalStorageSource<TData> extends BaseSource<TData> {
+    getFromSource(): string;
+    setToSource(value: string): void;
+}

package/dist/esm/hooks/useDataPersist/sources/localStorageSource.js

@@ -0,0 +1,15 @@
+import { isBrowser } from '../../../utils/index.js';
+import { BaseSource } from './baseSource.js';
+export class LocalStorageSource extends BaseSource {
+    getFromSource() {
+        if (isBrowser()) {
+            return localStorage.getItem(this.filterKey) || '';
+        }
+        return '';
+    }
+    setToSource(value) {
+        if (isBrowser()) {
+            localStorage.setItem(this.filterKey, value);
+        }
+    }
+}

package/dist/esm/hooks/useDataPersist/sources/queryParamSource.d.ts

@@ -0,0 +1,5 @@
+import { BaseSource } from './baseSource.js';
+export declare class QueryParamSource<TData> extends BaseSource<TData> {
+    getFromSource(): string;
+    setToSource(value: string): void;
+}

package/dist/esm/hooks/useDataPersist/sources/queryParamSource.js

@@ -0,0 +1,17 @@
+import { isBrowser } from '../../../utils/index.js';
+import { BaseSource } from './baseSource.js';
+export class QueryParamSource extends BaseSource {
+    getFromSource() {
+        if (isBrowser()) {
+            return new URL(window.location.href).searchParams.get(this.filterKey) || '';
+        }
+        return '';
+    }
+    setToSource(value) {
+        if (isBrowser()) {
+            const url = new URL(window.location.href);
+            url.searchParams.set(this.filterKey, value);
+            history.replaceState({}, '', url);
+        }
+    }
+}

package/dist/esm/hooks/useDataPersist/useDataPersist.d.ts

@@ -0,0 +1,16 @@
+import { type StateProps } from './useSource.js';
+export type DataPersistOptions<T> = {
+    queryKey: string;
+    localStorageKey: string;
+    validateData(value: unknown): value is T;
+};
+type DataPersistProps<TData> = Omit<StateProps<TData>, 'source'> & {
+    options?: DataPersistOptions<TData>;
+    parser?(jsonData: string): TData;
+    serializer?(data: TData): string;
+};
+export declare const useDataPersist: <TData>({ options, parser, serializer }: DataPersistProps<TData>) => {
+    getDefaultData: () => NonNullable<TData> | undefined;
+    setDataToStorages: (data: TData) => void;
+};
+export {};

package/dist/esm/hooks/useDataPersist/useDataPersist.js

@@ -0,0 +1,22 @@
+import { useCallback, useMemo } from 'react';
+import { LocalStorageSource, QueryParamSource } from './sources/index.js';
+import { useSource } from './useSource.js';
+export const useDataPersist = ({ options, parser, serializer }) => {
+    const querySource = useMemo(() => options ? new QueryParamSource(options.queryKey, options.validateData, parser, serializer) : undefined, [options, parser, serializer]);
+    const localStorageSource = useMemo(() => (options ? new LocalStorageSource(options.localStorageKey, options.validateData) : undefined), [options]);
+    const { getData: getLocalStorageData, setData: setLocalStorageData } = useSource({
+        source: localStorageSource,
+    });
+    const { getData: getQueryParamsData, setData: setQueryParamsData } = useSource({
+        source: querySource,
+    });
+    const setDataToStorages = useCallback((data) => {
+        setLocalStorageData(data);
+        setQueryParamsData(data);
+    }, [setLocalStorageData, setQueryParamsData]);
+    const getDefaultData = useCallback(() => {
+        const queryData = getQueryParamsData();
+        return queryData ?? getLocalStorageData();
+    }, [getLocalStorageData, getQueryParamsData]);
+    return { getDefaultData, setDataToStorages };
+};

package/dist/esm/hooks/useDataPersist/useSource.d.ts

@@ -0,0 +1,8 @@
+import { BaseSource } from './sources/index.js';
+export type StateProps<T> = {
+    source?: BaseSource<T>;
+};
+export declare const useSource: <T>({ source }: StateProps<T>) => {
+    getData: () => NonNullable<T> | undefined;
+    setData: (data: T) => void;
+};

package/dist/esm/hooks/useDataPersist/useSource.js

@@ -0,0 +1,11 @@
+import { useCallback } from 'react';
+export const useSource = ({ source }) => {
+    const setData = useCallback((data) => {
+        if (!source) {
+            return;
+        }
+        source.setData(data);
+    }, [source]);
+    const getData = useCallback(() => source?.getData() ?? undefined, [source]);
+    return { getData, setData };
+};

package/dist/esm/hooks/useDebounce.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Хук задерживает выполнение функции или обновление значения до тех пор,
+ * пока не пройдет определенный период времени без новых вызовов.
+ * @function React hook
+ */
+export declare function useDebounce(callback: () => void, timeout?: number): () => void;

package/dist/esm/hooks/useDebounce.js

@@ -0,0 +1,22 @@
+import { useRef } from 'react';
+import { isBrowser } from '../utils/index.js';
+import { useEventHandler } from './useEventHandler.js';
+/**
+ * Хук задерживает выполнение функции или обновление значения до тех пор,
+ * пока не пройдет определенный период времени без новых вызовов.
+ * @function React hook
+ */
+export function useDebounce(callback, timeout = 0) {
+    const timeStampRef = useRef(0);
+    const timerIdRef = useRef(null);
+    return useEventHandler(() => {
+        isBrowser() &&
+            requestAnimationFrame(timestamp => {
+                if (timestamp < timeStampRef.current && timerIdRef.current !== null) {
+                    clearTimeout(timerIdRef.current);
+                }
+                timerIdRef.current = setTimeout(callback, timeout);
+                timeStampRef.current = timestamp + timeout;
+            });
+    });
+}

package/dist/esm/hooks/useDynamicList.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+type UseDynamicListProps<T extends object> = {
+    items: T[];
+    resizingContainerRef?: RefObject<HTMLDivElement>;
+    parentContainerRef: RefObject<HTMLDivElement>;
+    maxVisibleItems?: number;
+};
+type UseDynamicListReturnType<T extends object> = {
+    visibleItems: T[];
+    hiddenItems: T[];
+};
+/**
+ * Хук позволяет распределять элементы списка на две группы: видимые и невидимые,
+ * в зависимости от ширины контейнера
+ * @function React hook
+ */
+export declare function useDynamicList<T extends object>({ parentContainerRef, resizingContainerRef, items, maxVisibleItems, }: UseDynamicListProps<T>): UseDynamicListReturnType<T>;
+export {};

package/dist/esm/hooks/useDynamicList.js

@@ -0,0 +1,96 @@
+import { useEffect, useRef, useState } from 'react';
+import { useEventHandler } from './useEventHandler.js';
+import { useLayoutEffect } from './useIsomorphicLayoutEffect.js';
+/**
+ * Хук позволяет распределять элементы списка на две группы: видимые и невидимые,
+ * в зависимости от ширины контейнера
+ * @function React hook
+ */
+export function useDynamicList({ parentContainerRef, resizingContainerRef = parentContainerRef, items, maxVisibleItems = Infinity, }) {
+    const adjustAmount = (value) => Math.min(maxVisibleItems, value);
+    const [visibleItemsAmount, setVisibleItemsAmount] = useState(adjustAmount(items.length));
+    const [width, setWidth] = useState(Infinity);
+    const widthRef = useRef(width);
+    const handleVisibleItemsAmount = param => {
+        if (typeof param === 'number') {
+            setVisibleItemsAmount(adjustAmount(param));
+        }
+        else {
+            setVisibleItemsAmount(v => param(adjustAmount(v)));
+        }
+    };
+    const tryHidingItem = useEventHandler(() => {
+        const container = parentContainerRef.current;
+        if (container && container.scrollWidth - container.offsetWidth > 0) {
+            const itemToHide = items[visibleItemsAmount - 1];
+            if (itemToHide) {
+                handleVisibleItemsAmount(value => value - 1);
+            }
+        }
+    });
+    const tryShowingItem = useEventHandler(() => {
+        const itemToShow = items[visibleItemsAmount];
+        if (itemToShow) {
+            handleVisibleItemsAmount(value => value + 1);
+        }
+    });
+    const toggleItemWidth = useEventHandler(({ changedWidth, initialWidth }) => {
+        if (changedWidth > initialWidth) {
+            //try to add extra item
+            if (visibleItemsAmount < maxVisibleItems) {
+                tryShowingItem();
+            }
+        }
+        else if (changedWidth < initialWidth) {
+            // check if item should be hidden
+            tryHidingItem();
+        }
+    });
+    useEffect(() => {
+        const listener = () => {
+            tryHidingItem();
+            if (parentContainerRef.current) {
+                setWidth(parentContainerRef.current.scrollWidth);
+            }
+        };
+        document.fonts.addEventListener('loadingdone', listener);
+        return () => document.fonts.removeEventListener('loadingdone', listener);
+    }, [parentContainerRef, tryHidingItem]);
+    useEffect(() => {
+        const container = resizingContainerRef.current;
+        if (container) {
+            const observer = new ResizeObserver(entities => entities.forEach(entity => {
+                if (entity.target === container) {
+                    const newWidth = entity.contentBoxSize[0]?.inlineSize;
+                    if (newWidth !== undefined) {
+                        setWidth(Math.floor(newWidth));
+                    }
+                }
+            }));
+            observer.observe(container);
+            return () => observer.disconnect();
+        }
+    }, [resizingContainerRef]);
+    useLayoutEffect(() => {
+        if (parentContainerRef.current) {
+            toggleItemWidth({
+                initialWidth: parentContainerRef.current.scrollWidth,
+                changedWidth: widthRef.current,
+            });
+        }
+    }, [items, parentContainerRef, toggleItemWidth]);
+    useLayoutEffect(() => {
+        toggleItemWidth({
+            initialWidth: widthRef.current,
+            changedWidth: width,
+        });
+        widthRef.current = width;
+    }, [width, toggleItemWidth]);
+    useLayoutEffect(() => {
+        tryHidingItem();
+    }, [tryHidingItem, visibleItemsAmount]);
+    return {
+        visibleItems: items.slice(0, visibleItemsAmount),
+        hiddenItems: items.slice(visibleItemsAmount),
+    };
+}

package/dist/esm/hooks/useEventHandler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Хук для создания обработчика событий с неизменной функцией.
+ * @function React hook
+ * @param handler коллбек события, без параметров
+ */
+export declare function useEventHandler<T extends (...args: never[]) => unknown>(handler: T): T;

package/dist/esm/hooks/useEventHandler.js

@@ -0,0 +1,20 @@
+import { useCallback, useRef } from 'react';
+import { useLayoutEffect } from './useIsomorphicLayoutEffect.js';
+/**
+ * Хук для создания обработчика событий с неизменной функцией.
+ * @function React hook
+ * @param handler коллбек события, без параметров
+ */
+export function useEventHandler(handler) {
+    const handlerRef = useRef(null);
+    useLayoutEffect(() => {
+        handlerRef.current = handler;
+    });
+    return useCallback((...args) => {
+        const handler = handlerRef.current;
+        if (handler === null) {
+            console.warn('The event handler cannot be called during render');
+        }
+        return handler?.(...args);
+    }, []);
+}

package/dist/esm/hooks/useHierarchicalSelection.d.ts

@@ -0,0 +1,12 @@
+import { HierarchicalSelectionConfig } from '../utils/hierarchicalSelection/createHierarchicalSelectionHandlers.js';
+/**
+ * Возвращает стабильные обработчики иерархического выбора с единым `includeParentsInValue`.
+ */
+export declare function useHierarchicalSelection({ includeParentsInValue }: HierarchicalSelectionConfig): {
+    getSelectionState<TId extends string | number>(params: import("..").HierarchicalSelectionNodeParams<TId>): {
+        checked: boolean;
+        indeterminate: boolean;
+    };
+    toggleSelection<TId extends string | number>(params: import("..").HierarchicalSelectionToggleParams<TId>): TId[];
+    checkGroupSelection: typeof import("..").checkGroupSelection;
+};

package/dist/esm/hooks/useHierarchicalSelection.js

@@ -0,0 +1,8 @@
+import { useMemo } from 'react';
+import { createHierarchicalSelectionHandlers, } from '../utils/hierarchicalSelection/createHierarchicalSelectionHandlers.js';
+/**
+ * Возвращает стабильные обработчики иерархического выбора с единым `includeParentsInValue`.
+ */
+export function useHierarchicalSelection({ includeParentsInValue }) {
+    return useMemo(() => createHierarchicalSelectionHandlers({ includeParentsInValue }), [includeParentsInValue]);
+}

package/dist/esm/hooks/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,7 @@
+import { useLayoutEffect as useLayoutEffectInternal } from 'react';
+/**
+ * Хук используется вместо стандартного useLayoutEffect-а,
+ * нужен для корректной работы SSR
+ * @function React hook
+ */
+export declare const useLayoutEffect: typeof useLayoutEffectInternal;

package/dist/esm/hooks/useIsomorphicLayoutEffect.js

@@ -0,0 +1,9 @@
+// eslint-disable-next-line no-restricted-imports
+import { useEffect, useLayoutEffect as useLayoutEffectInternal } from 'react';
+import { isBrowser } from '../utils/index.js';
+/**
+ * Хук используется вместо стандартного useLayoutEffect-а,
+ * нужен для корректной работы SSR
+ * @function React hook
+ */
+export const useLayoutEffect = isBrowser() ? useLayoutEffectInternal : useEffect;

package/dist/esm/hooks/useLocalStorage.d.ts

@@ -0,0 +1 @@
+export declare function useLocalStorage<T extends string = string>(key: string, defaultValue: T): [T, (newValue: T) => void];