@cloud-ru/ds-utils 1.0.0

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

@@ -0,0 +1,16 @@
+import { type StateProps } from './useSource';
+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/cjs/hooks/useDataPersist/useDataPersist.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataPersist = void 0;
+const react_1 = require("react");
+const sources_1 = require("./sources");
+const useSource_1 = require("./useSource");
+const useDataPersist = ({ options, parser, serializer }) => {
+    const querySource = (0, react_1.useMemo)(() => options ? new sources_1.QueryParamSource(options.queryKey, options.validateData, parser, serializer) : undefined, [options, parser, serializer]);
+    const localStorageSource = (0, react_1.useMemo)(() => (options ? new sources_1.LocalStorageSource(options.localStorageKey, options.validateData) : undefined), [options]);
+    const { getData: getLocalStorageData, setData: setLocalStorageData } = (0, useSource_1.useSource)({
+        source: localStorageSource,
+    });
+    const { getData: getQueryParamsData, setData: setQueryParamsData } = (0, useSource_1.useSource)({
+        source: querySource,
+    });
+    const setDataToStorages = (0, react_1.useCallback)((data) => {
+        setLocalStorageData(data);
+        setQueryParamsData(data);
+    }, [setLocalStorageData, setQueryParamsData]);
+    const getDefaultData = (0, react_1.useCallback)(() => {
+        const queryData = getQueryParamsData();
+        return queryData ?? getLocalStorageData();
+    }, [getLocalStorageData, getQueryParamsData]);
+    return { getDefaultData, setDataToStorages };
+};
+exports.useDataPersist = useDataPersist;

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

@@ -0,0 +1,8 @@
+import { BaseSource } from './sources';
+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/cjs/hooks/useDataPersist/useSource.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSource = void 0;
+const react_1 = require("react");
+const useSource = ({ source }) => {
+    const setData = (0, react_1.useCallback)((data) => {
+        if (!source) {
+            return;
+        }
+        source.setData(data);
+    }, [source]);
+    const getData = (0, react_1.useCallback)(() => source?.getData() ?? undefined, [source]);
+    return { getData, setData };
+};
+exports.useSource = useSource;

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

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

package/dist/cjs/hooks/useDebounce.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDebounce = useDebounce;
+const react_1 = require("react");
+const utils_1 = require("../utils");
+const useEventHandler_1 = require("./useEventHandler");
+/**
+ * Хук задерживает выполнение функции или обновление значения до тех пор,
+ * пока не пройдет определенный период времени без новых вызовов.
+ * @function React hook
+ */
+function useDebounce(callback, timeout = 0) {
+    const timeStampRef = (0, react_1.useRef)(0);
+    const timerIdRef = (0, react_1.useRef)(null);
+    return (0, useEventHandler_1.useEventHandler)(() => {
+        (0, utils_1.isBrowser)() &&
+            requestAnimationFrame(timestamp => {
+                if (timestamp < timeStampRef.current && timerIdRef.current !== null) {
+                    clearTimeout(timerIdRef.current);
+                }
+                timerIdRef.current = setTimeout(callback, timeout);
+                timeStampRef.current = timestamp + timeout;
+            });
+    });
+}

package/dist/cjs/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/cjs/hooks/useDynamicList.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDynamicList = useDynamicList;
+const react_1 = require("react");
+const useEventHandler_1 = require("./useEventHandler");
+const useIsomorphicLayoutEffect_1 = require("./useIsomorphicLayoutEffect");
+/**
+ * Хук позволяет распределять элементы списка на две группы: видимые и невидимые,
+ * в зависимости от ширины контейнера
+ * @function React hook
+ */
+function useDynamicList({ parentContainerRef, resizingContainerRef = parentContainerRef, items, maxVisibleItems = Infinity, }) {
+    const adjustAmount = (value) => Math.min(maxVisibleItems, value);
+    const [visibleItemsAmount, setVisibleItemsAmount] = (0, react_1.useState)(adjustAmount(items.length));
+    const [width, setWidth] = (0, react_1.useState)(Infinity);
+    const widthRef = (0, react_1.useRef)(width);
+    const handleVisibleItemsAmount = param => {
+        if (typeof param === 'number') {
+            setVisibleItemsAmount(adjustAmount(param));
+        }
+        else {
+            setVisibleItemsAmount(v => param(adjustAmount(v)));
+        }
+    };
+    const tryHidingItem = (0, useEventHandler_1.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 = (0, useEventHandler_1.useEventHandler)(() => {
+        const itemToShow = items[visibleItemsAmount];
+        if (itemToShow) {
+            handleVisibleItemsAmount(value => value + 1);
+        }
+    });
+    const toggleItemWidth = (0, useEventHandler_1.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();
+        }
+    });
+    (0, react_1.useEffect)(() => {
+        const listener = () => {
+            tryHidingItem();
+            if (parentContainerRef.current) {
+                setWidth(parentContainerRef.current.scrollWidth);
+            }
+        };
+        document.fonts.addEventListener('loadingdone', listener);
+        return () => document.fonts.removeEventListener('loadingdone', listener);
+    }, [parentContainerRef, tryHidingItem]);
+    (0, react_1.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]);
+    (0, useIsomorphicLayoutEffect_1.useLayoutEffect)(() => {
+        if (parentContainerRef.current) {
+            toggleItemWidth({
+                initialWidth: parentContainerRef.current.scrollWidth,
+                changedWidth: widthRef.current,
+            });
+        }
+    }, [items, parentContainerRef, toggleItemWidth]);
+    (0, useIsomorphicLayoutEffect_1.useLayoutEffect)(() => {
+        toggleItemWidth({
+            initialWidth: widthRef.current,
+            changedWidth: width,
+        });
+        widthRef.current = width;
+    }, [width, toggleItemWidth]);
+    (0, useIsomorphicLayoutEffect_1.useLayoutEffect)(() => {
+        tryHidingItem();
+    }, [tryHidingItem, visibleItemsAmount]);
+    return {
+        visibleItems: items.slice(0, visibleItemsAmount),
+        hiddenItems: items.slice(visibleItemsAmount),
+    };
+}

package/dist/cjs/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/cjs/hooks/useEventHandler.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEventHandler = useEventHandler;
+const react_1 = require("react");
+const useIsomorphicLayoutEffect_1 = require("./useIsomorphicLayoutEffect");
+/**
+ * Хук для создания обработчика событий с неизменной функцией.
+ * @function React hook
+ * @param handler коллбек события, без параметров
+ */
+function useEventHandler(handler) {
+    const handlerRef = (0, react_1.useRef)(null);
+    (0, useIsomorphicLayoutEffect_1.useLayoutEffect)(() => {
+        handlerRef.current = handler;
+    });
+    return (0, react_1.useCallback)((...args) => {
+        const handler = handlerRef.current;
+        if (handler === null) {
+            console.warn('The event handler cannot be called during render');
+        }
+        return handler?.(...args);
+    }, []);
+}

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

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

package/dist/cjs/hooks/useHierarchicalSelection.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHierarchicalSelection = useHierarchicalSelection;
+const react_1 = require("react");
+const createHierarchicalSelectionHandlers_1 = require("../utils/hierarchicalSelection/createHierarchicalSelectionHandlers");
+/**
+ * Возвращает стабильные обработчики иерархического выбора с единым `includeParentsInValue`.
+ */
+function useHierarchicalSelection({ includeParentsInValue }) {
+    return (0, react_1.useMemo)(() => (0, createHierarchicalSelectionHandlers_1.createHierarchicalSelectionHandlers)({ includeParentsInValue }), [includeParentsInValue]);
+}

package/dist/cjs/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/cjs/hooks/useIsomorphicLayoutEffect.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLayoutEffect = void 0;
+// eslint-disable-next-line no-restricted-imports
+const react_1 = require("react");
+const utils_1 = require("../utils");
+/**
+ * Хук используется вместо стандартного useLayoutEffect-а,
+ * нужен для корректной работы SSR
+ * @function React hook
+ */
+exports.useLayoutEffect = (0, utils_1.isBrowser)() ? react_1.useLayoutEffect : react_1.useEffect;

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

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

package/dist/cjs/hooks/useLocalStorage.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLocalStorage = useLocalStorage;
+const react_1 = require("react");
+const utils_1 = require("../utils");
+function useLocalStorage(key, defaultValue) {
+    const [value, setValueState] = (0, react_1.useState)((((0, utils_1.isBrowser)() ? localStorage.getItem(key) : null) ?? defaultValue));
+    const setValue = (0, react_1.useCallback)((newValue) => {
+        if ((0, utils_1.isBrowser)()) {
+            localStorage.setItem(key, newValue);
+        }
+        setValueState(newValue);
+    }, [key]);
+    return [value, setValue];
+}

package/dist/cjs/hooks/useModalOpenState.d.ts

@@ -0,0 +1,18 @@
+type UseModalOpenStateOptions = {
+    /** закрывать модалку при переходе по истории браузера (по умолчанию false) */
+    closeOnPopstate?: boolean;
+    /** закрывать модалку через CloseWatcher (по умолчанию true) */
+    closeByCloseWatcher?: boolean;
+};
+/**
+ * Хук для управления состоянием модалки
+ * @returns [open, onClose]
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CloseWatcher
+ * @function hook
+ */
+export declare function useModalOpenState(
+/** состояние модалки */
+open: boolean, 
+/** колбек закрытия */
+onClose: () => void, { closeOnPopstate, closeByCloseWatcher }: UseModalOpenStateOptions): void;
+export {};

package/dist/cjs/hooks/useModalOpenState.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useModalOpenState = useModalOpenState;
+const react_1 = require("react");
+const useEventHandler_1 = require("./useEventHandler");
+const usePopstateSubscription_1 = require("./usePopstateSubscription");
+/**
+ * Хук для управления состоянием модалки
+ * @returns [open, onClose]
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CloseWatcher
+ * @function hook
+ */
+function useModalOpenState(
+/** состояние модалки */
+open, 
+/** колбек закрытия */
+onClose, { closeOnPopstate = false, closeByCloseWatcher = true }) {
+    const closeHandler = (0, useEventHandler_1.useEventHandler)(onClose);
+    (0, usePopstateSubscription_1.usePopstateSubscription)(() => open && closeHandler(), closeOnPopstate);
+    (0, react_1.useEffect)(() => {
+        if (open && 'CloseWatcher' in window && closeByCloseWatcher) {
+            const watcher = new CloseWatcher();
+            watcher.onclose = () => closeHandler();
+            return () => watcher.destroy();
+        }
+    }, [open, closeHandler, closeByCloseWatcher]);
+}

package/dist/cjs/hooks/usePopstateSubscription.d.ts

@@ -0,0 +1 @@
+export declare function usePopstateSubscription(callback: (e: PopStateEvent) => void, enabled?: boolean): void;

package/dist/cjs/hooks/usePopstateSubscription.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePopstateSubscription = usePopstateSubscription;
+const react_1 = require("react");
+const useEventHandler_1 = require("./useEventHandler");
+function usePopstateSubscription(callback, enabled = true) {
+    const handler = (0, useEventHandler_1.useEventHandler)(callback);
+    (0, react_1.useEffect)(() => {
+        if (!enabled)
+            return;
+        window.addEventListener('popstate', handler);
+        return () => window.removeEventListener('popstate', handler);
+    }, [enabled, handler]);
+}

package/dist/cjs/hooks/useSwipeable.d.ts

@@ -0,0 +1,21 @@
+import { SwipeableHandlers, SwipeableProps, SwipeCallback, SwipeDirections, SwipeEventData } from 'react-swipeable';
+export declare const DATA_SWIPE_DIRECTIONS_ATTRIBUTE = "data-swipe-directions";
+export type UseSwipeProps = {
+    /**
+     * Включен ли свайп
+     */
+    enabled?: boolean;
+    /**
+     * Направления, в которых будет работать свайп.
+     * Укажите это свойство, чтобы предотвратить конфликты и заблокировать свайп в родительских элементах по этим направлениям.
+     */
+    availableDirections?: SwipeDirections[];
+} & SwipeableProps;
+export type UseSwipeReturnType = SwipeableHandlers & {
+    [DATA_SWIPE_DIRECTIONS_ATTRIBUTE]?: string;
+};
+/**
+ * Хук для работы с событиями свайпа
+ */
+export declare function useSwipeable({ availableDirections, enabled, ...options }: UseSwipeProps): UseSwipeReturnType;
+export type { SwipeCallback, SwipeDirections, SwipeEventData };

package/dist/cjs/hooks/useSwipeable.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATA_SWIPE_DIRECTIONS_ATTRIBUTE = void 0;
+exports.useSwipeable = useSwipeable;
+const react_1 = require("react");
+const react_swipeable_1 = require("react-swipeable");
+exports.DATA_SWIPE_DIRECTIONS_ATTRIBUTE = 'data-swipe-directions';
+/**
+ * Хук для работы с событиями свайпа
+ */
+function useSwipeable({ availableDirections, enabled = true, ...options }) {
+    const canSwipe = (0, react_1.useRef)(true);
+    const onSwipeStart = eventData => {
+        if (availableDirections) {
+            if (!availableDirections.includes(eventData.dir)) {
+                canSwipe.current = false;
+                return;
+            }
+            if (!options.onSwipeStart) {
+                return;
+            }
+            eventData.event.stopPropagation();
+        }
+        options.onSwipeStart?.(eventData);
+    };
+    const onSwiping = eventData => {
+        if (availableDirections) {
+            if (!canSwipe.current) {
+                return;
+            }
+            eventData.event.stopPropagation();
+        }
+        options.onSwiping?.(eventData);
+    };
+    const onSwiped = eventData => {
+        if (availableDirections) {
+            if (!canSwipe.current) {
+                canSwipe.current = true;
+                return;
+            }
+            eventData.event.stopPropagation();
+        }
+        options.onSwiped?.(eventData);
+    };
+    const handlers = (0, react_swipeable_1.useSwipeable)(enabled ? { ...options, onSwipeStart, onSwiping, onSwiped } : {});
+    return {
+        ...handlers,
+        [exports.DATA_SWIPE_DIRECTIONS_ATTRIBUTE]: enabled && availableDirections ? availableDirections.join(' ') : undefined,
+    };
+}

package/dist/cjs/hooks/useUncontrolledProp.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Сигнатура колбэка смены значения.
+ *
+ * `any` здесь — не небрежность, а воспроизведение публичного типа пакета `uncontrollable`,
+ * на месте которого стоит этот хук. Свободный тип позволяет и колбэки с дополнительными
+ * аргументами (`onSelect(key, node)`), и функциональные апдейтеры (`setValue(prev => …)`,
+ * которые дальше применяет `useState`). Сузить его нельзя, не переписав типы `ToggleGroup`,
+ * `SelectionProvider` и `TreeContext`, — это отдельная задача.
+ */
+export type UncontrolledHandler = (value: any, ...args: any[]) => any;
+/**
+ * Пара «значение + сеттер» для пропа, который работает и в controlled, и в uncontrolled режиме.
+ * Пока `propValue` задан — источник истины он, а сеттер только зовёт `handler`. Как только
+ * `propValue` становится `undefined`, состояние переходит во внутренний `useState`
+ * и сбрасывается на `defaultValue`.
+ *
+ * Сеттер стабилен между рендерами, пока не меняется `handler`.
+ * @function React hook
+ */
+export declare function useUncontrolledProp<TValue, THandler extends UncontrolledHandler = UncontrolledHandler>(propValue: TValue | undefined, defaultValue: TValue, handler?: THandler): readonly [TValue, THandler];
+export declare function useUncontrolledProp<TValue, THandler extends UncontrolledHandler = UncontrolledHandler>(propValue: TValue | undefined, defaultValue?: TValue, handler?: THandler): readonly [TValue | undefined, (...args: Parameters<THandler>) => ReturnType<THandler> | void];

package/dist/cjs/hooks/useUncontrolledProp.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUncontrolledProp = useUncontrolledProp;
+const react_1 = require("react");
+function useUncontrolledProp(propValue, defaultValue, handler) {
+    const isProp = propValue !== undefined;
+    const wasPropRef = (0, react_1.useRef)(isProp);
+    const [stateValue, setStateValue] = (0, react_1.useState)(defaultValue);
+    const wasProp = wasPropRef.current;
+    wasPropRef.current = isProp;
+    // Переход controlled -> uncontrolled: внутреннее состояние отстало от `defaultValue`,
+    // возвращаем его к дефолту, иначе компонент «залипнет» на последнем controlled-значении.
+    if (!isProp && wasProp && stateValue !== defaultValue) {
+        setStateValue(defaultValue);
+    }
+    const setValue = (0, react_1.useCallback)((...args) => {
+        const [value, ...rest] = args;
+        const returnValue = handler?.(value, ...rest);
+        setStateValue(value);
+        return returnValue;
+    }, [handler]);
+    return [isProp ? propValue : stateValue, setValue];
+}

package/dist/cjs/hooks/useValueControl.d.ts

@@ -0,0 +1,20 @@
+type UseValueControl<TValue> = {
+    /**
+     * Значение состояния
+     */
+    value?: TValue;
+    /**
+     * Значение по умолчанию
+     */
+    defaultValue?: TValue;
+    /**
+     * Колбек, вызываемый на смену состояния
+     */
+    onChange?(value: TValue): void;
+};
+/**
+ * Хук для работы с состоянием.
+ * Нужен для поддержки controlled/uncontrolled поведения, в зависимости от того были ли переданы входные аргументы
+ */
+export declare function useValueControl<TValue>({ value, onChange, defaultValue }: UseValueControl<TValue>): readonly [TValue | undefined, (value: any, ...args: any[]) => any];
+export {};

package/dist/cjs/hooks/useValueControl.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useValueControl = useValueControl;
+const react_1 = require("react");
+const useUncontrolledProp_1 = require("./useUncontrolledProp");
+/**
+ * Хук для работы с состоянием.
+ * Нужен для поддержки controlled/uncontrolled поведения, в зависимости от того были ли переданы входные аргументы
+ */
+function useValueControl({ value, onChange, defaultValue }) {
+    // Значение читаем из ref: иначе handler пересоздавался бы на каждую смену `value`,
+    // а вместе с ним — и сеттер из `useUncontrolledProp`.
+    const valueRef = (0, react_1.useRef)(value);
+    valueRef.current = value;
+    const handleChange = (0, react_1.useCallback)((newValue) => {
+        const newState = typeof newValue === 'function' ? newValue(valueRef.current) : newValue;
+        onChange?.(newState);
+    }, [onChange]);
+    return (0, useUncontrolledProp_1.useUncontrolledProp)(value, defaultValue, handleChange);
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hooks';
+export * from './utils';
+export * from './types';

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./types"), exports);

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './polymorphic';
+export * from './valueOf';

package/dist/cjs/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./polymorphic"), exports);
+__exportStar(require("./valueOf"), exports);

package/dist/cjs/types/polymorphic.d.ts

@@ -0,0 +1,3 @@
+import { ComponentPropsWithRef, ElementType } from 'react';
+/** Тип ref'а для полиморфного компонента: то, что примет элемент/компонент, переданный в `as`. */
+export type PolymorphicRef<T extends ElementType> = ComponentPropsWithRef<T>['ref'];

package/dist/cjs/types/polymorphic.js

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

package/dist/cjs/types/valueOf.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Utility-тип, преобразующий константные значения объекта в union
+ * @function type
+ */
+export type ValueOf<T> = T[keyof T];

package/dist/cjs/types/valueOf.js

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