@cloud-ru/ds-utils 1.0.0

package/dist/esm/hooks/useLocalStorage.js

@@ -0,0 +1,12 @@
+import { useCallback, useState } from 'react';
+import { isBrowser } from '../utils/index.js';
+export function useLocalStorage(key, defaultValue) {
+    const [value, setValueState] = useState(((isBrowser() ? localStorage.getItem(key) : null) ?? defaultValue));
+    const setValue = useCallback((newValue) => {
+        if (isBrowser()) {
+            localStorage.setItem(key, newValue);
+        }
+        setValueState(newValue);
+    }, [key]);
+    return [value, setValue];
+}

package/dist/esm/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/esm/hooks/useModalOpenState.js

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

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

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

package/dist/esm/hooks/usePopstateSubscription.js

@@ -0,0 +1,11 @@
+import { useEffect } from 'react';
+import { useEventHandler } from './useEventHandler.js';
+export function usePopstateSubscription(callback, enabled = true) {
+    const handler = useEventHandler(callback);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        window.addEventListener('popstate', handler);
+        return () => window.removeEventListener('popstate', handler);
+    }, [enabled, handler]);
+}

package/dist/esm/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/esm/hooks/useSwipeable.js

@@ -0,0 +1,46 @@
+import { useRef } from 'react';
+import { useSwipeable as useSwipeableInternal, } from 'react-swipeable';
+export const DATA_SWIPE_DIRECTIONS_ATTRIBUTE = 'data-swipe-directions';
+/**
+ * Хук для работы с событиями свайпа
+ */
+export function useSwipeable({ availableDirections, enabled = true, ...options }) {
+    const canSwipe = 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 = useSwipeableInternal(enabled ? { ...options, onSwipeStart, onSwiping, onSwiped } : {});
+    return {
+        ...handlers,
+        [DATA_SWIPE_DIRECTIONS_ATTRIBUTE]: enabled && availableDirections ? availableDirections.join(' ') : undefined,
+    };
+}

package/dist/esm/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/esm/hooks/useUncontrolledProp.js

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

package/dist/esm/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/esm/hooks/useValueControl.js

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

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

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

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

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

package/dist/esm/types/index.js

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

package/dist/esm/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/esm/types/polymorphic.js

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

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

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

package/dist/esm/types/valueOf.js

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

package/dist/esm/utils/componentPropsProcessors.d.ts

@@ -0,0 +1,19 @@
+import { AriaAttributes } from 'react';
+export type WithSupportProps<T> = {
+    'data-test-id'?: string;
+} & AriaAttributes & T;
+/**
+ * Функция для исключения вспомогательных свойств (data-test-id & aria-*)
+ * @function helper
+ */
+export declare function excludeSupportProps<T extends Record<string, unknown>>(props: T): {};
+/**
+ * Функция для отбора свойства data-test-id
+ * @function helper
+ */
+export declare function extractDataTestProps<T extends Record<string, unknown>>(props: T): Record<string, unknown>;
+/**
+ * Функция для отбора вспомогательных свойств (data-test-id & aria-*)
+ * @function helper
+ */
+export declare function extractSupportProps<T extends Record<string, unknown>>(props: T): Record<string, unknown>;

package/dist/esm/utils/componentPropsProcessors.js

@@ -0,0 +1,38 @@
+const DATA_TEST_REGEXP = /^data-test-/;
+const DATA_AND_ARIA_REGEXP = /^(data|aria)-/;
+function excludeProps(props, regexp) {
+    return Object.keys(props)
+        .filter(prop => !prop.match(regexp))
+        .reduce((nextProps, prop) => ({
+        ...nextProps,
+        [prop]: props[prop],
+    }), {});
+}
+function extractProps(props, regex) {
+    return Object.keys(props).reduce((nextProps, prop) => {
+        if (prop.match(regex))
+            nextProps[prop] = props[prop];
+        return nextProps;
+    }, {});
+}
+/**
+ * Функция для исключения вспомогательных свойств (data-test-id & aria-*)
+ * @function helper
+ */
+export function excludeSupportProps(props) {
+    return excludeProps(props, DATA_AND_ARIA_REGEXP);
+}
+/**
+ * Функция для отбора свойства data-test-id
+ * @function helper
+ */
+export function extractDataTestProps(props) {
+    return extractProps(props, DATA_TEST_REGEXP);
+}
+/**
+ * Функция для отбора вспомогательных свойств (data-test-id & aria-*)
+ * @function helper
+ */
+export function extractSupportProps(props) {
+    return extractProps(props, DATA_AND_ARIA_REGEXP);
+}

package/dist/esm/utils/copyToClipboard.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Копирует текст в буфер обмена. Сначала пробует Async Clipboard API, при отказе
+ * (нет разрешения, insecure-context) падает на `execCommand('copy')` со скрытым textarea.
+ *
+ * Возвращает `true`, если запись удалась — по этому признаку поля и кнопки показывают
+ * индикатор «скопировано».
+ *
+ * Проверки `isBrowser()` продублированы внутри веток намеренно: правило
+ * `@cloud-ru/ssr-safe-react/domApi` требует, чтобы доступ к `navigator`/`document` стоял
+ * непосредственно внутри такого условия, а ранний выход оно не учитывает.
+ */
+export declare function copyToClipboard(value: string): Promise<boolean>;

package/dist/esm/utils/copyToClipboard.js

@@ -0,0 +1,44 @@
+import { isBrowser } from './isBrowser.js';
+/**
+ * Копирует текст в буфер обмена. Сначала пробует Async Clipboard API, при отказе
+ * (нет разрешения, insecure-context) падает на `execCommand('copy')` со скрытым textarea.
+ *
+ * Возвращает `true`, если запись удалась — по этому признаку поля и кнопки показывают
+ * индикатор «скопировано».
+ *
+ * Проверки `isBrowser()` продублированы внутри веток намеренно: правило
+ * `@cloud-ru/ssr-safe-react/domApi` требует, чтобы доступ к `navigator`/`document` стоял
+ * непосредственно внутри такого условия, а ранний выход оно не учитывает.
+ */
+export async function copyToClipboard(value) {
+    if (!isBrowser())
+        return false;
+    if (isBrowser() && navigator.clipboard?.writeText) {
+        try {
+            await navigator.clipboard.writeText(value);
+            return true;
+        }
+        catch {
+            // fall through to execCommand fallback
+        }
+    }
+    if (isBrowser()) {
+        const textarea = document.createElement('textarea');
+        textarea.value = value;
+        textarea.setAttribute('readonly', '');
+        textarea.style.position = 'fixed';
+        textarea.style.opacity = '0';
+        document.body.appendChild(textarea);
+        textarea.select();
+        try {
+            return document.execCommand('copy');
+        }
+        catch {
+            return false;
+        }
+        finally {
+            document.body.removeChild(textarea);
+        }
+    }
+    return false;
+}

package/dist/esm/utils/debounce.d.ts

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

package/dist/esm/utils/debounce.js

@@ -0,0 +1,21 @@
+/**
+ * Откладывает вызов `callback` на `wait` мс, перезапуская таймер на каждом новом вызове.
+ * Срабатывает по заднему фронту — с аргументами последнего вызова.
+ */
+export function debounce(callback, wait = 0) {
+    let timer;
+    const cancel = () => {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+    const debounced = (...args) => {
+        cancel();
+        timer = setTimeout(() => {
+            timer = undefined;
+            callback(...args);
+        }, wait);
+    };
+    return Object.assign(debounced, { cancel });
+}

package/dist/esm/utils/hierarchicalSelection/applySelectionDiff.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Применяет diff к набору выбранных id.
+ */
+export declare function applySelectionDiff<TId extends string | number>(selectedIds: TId[], added: TId[], removed: TId[]): TId[];

package/dist/esm/utils/hierarchicalSelection/applySelectionDiff.js

@@ -0,0 +1,13 @@
+/**
+ * Применяет diff к набору выбранных id.
+ */
+export function applySelectionDiff(selectedIds, added, removed) {
+    const result = new Set(selectedIds);
+    for (const id of added) {
+        result.add(id);
+    }
+    for (const id of removed) {
+        result.delete(id);
+    }
+    return [...result];
+}

package/dist/esm/utils/hierarchicalSelection/checkGroupSelection.d.ts

@@ -0,0 +1,5 @@
+import { GroupSelectionState } from './types.js';
+/**
+ * Проверяет состояние выбора группы по flat-списку дочерних id.
+ */
+export declare function checkGroupSelection<TId extends string | number>(childIds: TId[], selectedIds: TId[]): GroupSelectionState;

package/dist/esm/utils/hierarchicalSelection/checkGroupSelection.js

@@ -0,0 +1,15 @@
+/**
+ * Проверяет состояние выбора группы по flat-списку дочерних id.
+ */
+export function checkGroupSelection(childIds, selectedIds) {
+    if (!childIds.length) {
+        return { allSelected: false, someSelected: false };
+    }
+    const selectedCount = childIds.filter(id => selectedIds.includes(id)).length;
+    const someSelected = selectedCount > 0;
+    const allSelected = someSelected && selectedCount === childIds.length;
+    return {
+        allSelected,
+        someSelected: !allSelected && someSelected,
+    };
+}

package/dist/esm/utils/hierarchicalSelection/createHierarchicalSelectionHandlers.d.ts

@@ -0,0 +1,19 @@
+import { checkGroupSelection } from './checkGroupSelection.js';
+import { GetNodeSelectionStateParams, ToggleHierarchicalSelectionParams } from './types.js';
+export type HierarchicalSelectionConfig = {
+    includeParentsInValue: boolean;
+};
+export type HierarchicalSelectionNodeParams<TId extends string | number = string> = Omit<GetNodeSelectionStateParams<TId>, 'includeParentsInValue'>;
+export type HierarchicalSelectionToggleParams<TId extends string | number = string> = Omit<ToggleHierarchicalSelectionParams<TId>, 'includeParentsInValue'>;
+/**
+ * Создаёт набор обработчиков иерархического выбора с единым `includeParentsInValue`.
+ */
+export declare function createHierarchicalSelectionHandlers({ includeParentsInValue }: HierarchicalSelectionConfig): {
+    getSelectionState<TId extends string | number>(params: HierarchicalSelectionNodeParams<TId>): {
+        checked: boolean;
+        indeterminate: boolean;
+    };
+    toggleSelection<TId extends string | number>(params: HierarchicalSelectionToggleParams<TId>): TId[];
+    checkGroupSelection: typeof checkGroupSelection;
+};
+export type HierarchicalSelectionHandlers = ReturnType<typeof createHierarchicalSelectionHandlers>;

package/dist/esm/utils/hierarchicalSelection/createHierarchicalSelectionHandlers.js

@@ -0,0 +1,17 @@
+import { checkGroupSelection } from './checkGroupSelection.js';
+import { getNodeSelectionState } from './getNodeSelectionState.js';
+import { toggleHierarchicalSelection } from './toggleHierarchicalSelection.js';
+/**
+ * Создаёт набор обработчиков иерархического выбора с единым `includeParentsInValue`.
+ */
+export function createHierarchicalSelectionHandlers({ includeParentsInValue }) {
+    return {
+        getSelectionState(params) {
+            return getNodeSelectionState({ ...params, includeParentsInValue });
+        },
+        toggleSelection(params) {
+            return toggleHierarchicalSelection({ ...params, includeParentsInValue });
+        },
+        checkGroupSelection,
+    };
+}

package/dist/esm/utils/hierarchicalSelection/getNodeSelectionState.d.ts

@@ -0,0 +1,8 @@
+import { GetNodeSelectionStateParams } from './types.js';
+/**
+ * Единая формула checked/indeterminate для иерархического мультивыбора.
+ */
+export declare function getNodeSelectionState<TId extends string | number>({ nodeId, childIds, selectedIds, includeParentsInValue, }: GetNodeSelectionStateParams<TId>): {
+    checked: boolean;
+    indeterminate: boolean;
+};

package/dist/esm/utils/hierarchicalSelection/getNodeSelectionState.js

@@ -0,0 +1,19 @@
+import { checkGroupSelection } from './checkGroupSelection.js';
+/**
+ * Единая формула checked/indeterminate для иерархического мультивыбора.
+ */
+export function getNodeSelectionState({ nodeId, childIds, selectedIds, includeParentsInValue, }) {
+    const { allSelected, someSelected } = checkGroupSelection(childIds, selectedIds);
+    if (!includeParentsInValue) {
+        return {
+            checked: allSelected,
+            indeterminate: someSelected,
+        };
+    }
+    const inValue = selectedIds.includes(nodeId);
+    const checked = inValue || allSelected;
+    return {
+        checked,
+        indeterminate: !checked && someSelected,
+    };
+}

package/dist/esm/utils/hierarchicalSelection/index.d.ts

@@ -0,0 +1,6 @@
+export * from './applySelectionDiff.js';
+export * from './checkGroupSelection.js';
+export * from './createHierarchicalSelectionHandlers.js';
+export * from './getNodeSelectionState.js';
+export * from './toggleHierarchicalSelection.js';
+export * from './types.js';

package/dist/esm/utils/hierarchicalSelection/index.js

@@ -0,0 +1,6 @@
+export * from './applySelectionDiff.js';
+export * from './checkGroupSelection.js';
+export * from './createHierarchicalSelectionHandlers.js';
+export * from './getNodeSelectionState.js';
+export * from './toggleHierarchicalSelection.js';
+export * from './types.js';

package/dist/esm/utils/hierarchicalSelection/toggleHierarchicalSelection.d.ts

@@ -0,0 +1,5 @@
+import { ToggleHierarchicalSelectionParams } from './types.js';
+/**
+ * Пересчитывает выбранные id после toggle узла с каскадом вниз и опциональным walk вверх.
+ */
+export declare function toggleHierarchicalSelection<TId extends string | number>(params: ToggleHierarchicalSelectionParams<TId>): TId[];

package/dist/esm/utils/hierarchicalSelection/toggleHierarchicalSelection.js

@@ -0,0 +1,66 @@
+import { checkGroupSelection } from './checkGroupSelection.js';
+function resolveIsSelected({ nodeId, descendantIds, selectableDescendantIds, childIds, selectedIds, includeParentsInValue, }) {
+    const hasDescendants = descendantIds.length > 0;
+    if (!includeParentsInValue && hasDescendants) {
+        const idsForChecked = childIds ?? descendantIds;
+        const selectable = selectableDescendantIds ?? descendantIds;
+        const allChildrenSelected = idsForChecked.length > 0 && idsForChecked.every(id => selectedIds.includes(id));
+        const allEnabledSelected = selectable.length > 0 && selectable.every(id => selectedIds.includes(id));
+        return allChildrenSelected || allEnabledSelected;
+    }
+    if (hasDescendants) {
+        const { allSelected, someSelected } = checkGroupSelection(descendantIds, selectedIds);
+        return allSelected || someSelected;
+    }
+    return selectedIds.includes(nodeId);
+}
+function toggleWithParentsInValue({ nodeId, descendantIds, selectedIds, ancestors, isSelected, }) {
+    const idsFromNode = [nodeId, ...descendantIds];
+    let updatedSelectedIds = isSelected
+        ? selectedIds.filter(id => !idsFromNode.includes(id))
+        : [...selectedIds, ...idsFromNode.filter(id => !selectedIds.includes(id))];
+    if (!ancestors?.length) {
+        return updatedSelectedIds;
+    }
+    for (const ancestor of ancestors) {
+        if (!ancestor.childIds.length) {
+            continue;
+        }
+        const parentSelection = checkGroupSelection(ancestor.childIds, updatedSelectedIds);
+        if (isSelected) {
+            if (!parentSelection.allSelected) {
+                updatedSelectedIds = updatedSelectedIds.filter(id => id !== ancestor.id);
+            }
+        }
+        else if (parentSelection.allSelected && !updatedSelectedIds.includes(ancestor.id)) {
+            updatedSelectedIds = [...updatedSelectedIds, ancestor.id];
+        }
+    }
+    return updatedSelectedIds;
+}
+function toggleWithoutParentsInValue({ nodeId, descendantIds, selectableDescendantIds, selectedIds, isSelected, }) {
+    if (!descendantIds.length) {
+        if (isSelected) {
+            return selectedIds.filter(id => id !== nodeId);
+        }
+        if (selectedIds.includes(nodeId)) {
+            return selectedIds;
+        }
+        return [...selectedIds, nodeId];
+    }
+    const selectable = selectableDescendantIds ?? descendantIds;
+    if (isSelected) {
+        return selectedIds.filter(id => id !== nodeId && !selectable.includes(id));
+    }
+    return [...new Set([...selectedIds, ...selectable])];
+}
+/**
+ * Пересчитывает выбранные id после toggle узла с каскадом вниз и опциональным walk вверх.
+ */
+export function toggleHierarchicalSelection(params) {
+    const isSelected = resolveIsSelected(params);
+    if (params.includeParentsInValue) {
+        return toggleWithParentsInValue({ ...params, isSelected });
+    }
+    return toggleWithoutParentsInValue({ ...params, isSelected });
+}