@cloud-ru/ds-utils 1.0.0

package/dist/cjs/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/cjs/utils/componentPropsProcessors.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.excludeSupportProps = excludeSupportProps;
+exports.extractDataTestProps = extractDataTestProps;
+exports.extractSupportProps = extractSupportProps;
+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
+ */
+function excludeSupportProps(props) {
+    return excludeProps(props, DATA_AND_ARIA_REGEXP);
+}
+/**
+ * Функция для отбора свойства data-test-id
+ * @function helper
+ */
+function extractDataTestProps(props) {
+    return extractProps(props, DATA_TEST_REGEXP);
+}
+/**
+ * Функция для отбора вспомогательных свойств (data-test-id & aria-*)
+ * @function helper
+ */
+function extractSupportProps(props) {
+    return extractProps(props, DATA_AND_ARIA_REGEXP);
+}

package/dist/cjs/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/cjs/utils/copyToClipboard.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyToClipboard = copyToClipboard;
+const isBrowser_1 = require("./isBrowser");
+/**
+ * Копирует текст в буфер обмена. Сначала пробует Async Clipboard API, при отказе
+ * (нет разрешения, insecure-context) падает на `execCommand('copy')` со скрытым textarea.
+ *
+ * Возвращает `true`, если запись удалась — по этому признаку поля и кнопки показывают
+ * индикатор «скопировано».
+ *
+ * Проверки `isBrowser()` продублированы внутри веток намеренно: правило
+ * `@cloud-ru/ssr-safe-react/domApi` требует, чтобы доступ к `navigator`/`document` стоял
+ * непосредственно внутри такого условия, а ранний выход оно не учитывает.
+ */
+async function copyToClipboard(value) {
+    if (!(0, isBrowser_1.isBrowser)())
+        return false;
+    if ((0, isBrowser_1.isBrowser)() && navigator.clipboard?.writeText) {
+        try {
+            await navigator.clipboard.writeText(value);
+            return true;
+        }
+        catch {
+            // fall through to execCommand fallback
+        }
+    }
+    if ((0, isBrowser_1.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/cjs/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/cjs/utils/debounce.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = debounce;
+/**
+ * Откладывает вызов `callback` на `wait` мс, перезапуская таймер на каждом новом вызове.
+ * Срабатывает по заднему фронту — с аргументами последнего вызова.
+ */
+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/cjs/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/cjs/utils/hierarchicalSelection/applySelectionDiff.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySelectionDiff = applySelectionDiff;
+/**
+ * Применяет diff к набору выбранных id.
+ */
+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/cjs/utils/hierarchicalSelection/checkGroupSelection.d.ts

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

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkGroupSelection = checkGroupSelection;
+/**
+ * Проверяет состояние выбора группы по flat-списку дочерних id.
+ */
+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/cjs/utils/hierarchicalSelection/createHierarchicalSelectionHandlers.d.ts

@@ -0,0 +1,19 @@
+import { checkGroupSelection } from './checkGroupSelection';
+import { GetNodeSelectionStateParams, ToggleHierarchicalSelectionParams } from './types';
+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/cjs/utils/hierarchicalSelection/createHierarchicalSelectionHandlers.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHierarchicalSelectionHandlers = createHierarchicalSelectionHandlers;
+const checkGroupSelection_1 = require("./checkGroupSelection");
+const getNodeSelectionState_1 = require("./getNodeSelectionState");
+const toggleHierarchicalSelection_1 = require("./toggleHierarchicalSelection");
+/**
+ * Создаёт набор обработчиков иерархического выбора с единым `includeParentsInValue`.
+ */
+function createHierarchicalSelectionHandlers({ includeParentsInValue }) {
+    return {
+        getSelectionState(params) {
+            return (0, getNodeSelectionState_1.getNodeSelectionState)({ ...params, includeParentsInValue });
+        },
+        toggleSelection(params) {
+            return (0, toggleHierarchicalSelection_1.toggleHierarchicalSelection)({ ...params, includeParentsInValue });
+        },
+        checkGroupSelection: checkGroupSelection_1.checkGroupSelection,
+    };
+}

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeSelectionState = getNodeSelectionState;
+const checkGroupSelection_1 = require("./checkGroupSelection");
+/**
+ * Единая формула checked/indeterminate для иерархического мультивыбора.
+ */
+function getNodeSelectionState({ nodeId, childIds, selectedIds, includeParentsInValue, }) {
+    const { allSelected, someSelected } = (0, checkGroupSelection_1.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/cjs/utils/hierarchicalSelection/index.d.ts

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

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

@@ -0,0 +1,22 @@
+"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("./applySelectionDiff"), exports);
+__exportStar(require("./checkGroupSelection"), exports);
+__exportStar(require("./createHierarchicalSelectionHandlers"), exports);
+__exportStar(require("./getNodeSelectionState"), exports);
+__exportStar(require("./toggleHierarchicalSelection"), exports);
+__exportStar(require("./types"), exports);

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

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

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleHierarchicalSelection = toggleHierarchicalSelection;
+const checkGroupSelection_1 = require("./checkGroupSelection");
+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 } = (0, checkGroupSelection_1.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 = (0, checkGroupSelection_1.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 вверх.
+ */
+function toggleHierarchicalSelection(params) {
+    const isSelected = resolveIsSelected(params);
+    if (params.includeParentsInValue) {
+        return toggleWithParentsInValue({ ...params, isSelected });
+    }
+    return toggleWithoutParentsInValue({ ...params, isSelected });
+}

package/dist/cjs/utils/hierarchicalSelection/types.d.ts

@@ -0,0 +1,23 @@
+export type GroupSelectionState = {
+    allSelected: boolean;
+    someSelected: boolean;
+};
+export type HierarchicalAncestor<TId extends string | number = string> = {
+    id: TId;
+    childIds: TId[];
+};
+export type GetNodeSelectionStateParams<TId extends string | number = string> = {
+    nodeId: TId;
+    childIds: TId[];
+    selectedIds: TId[];
+    includeParentsInValue: boolean;
+};
+export type ToggleHierarchicalSelectionParams<TId extends string | number = string> = {
+    nodeId: TId;
+    descendantIds: TId[];
+    selectableDescendantIds?: TId[];
+    childIds?: TId[];
+    selectedIds: TId[];
+    ancestors?: HierarchicalAncestor<TId>[];
+    includeParentsInValue: boolean;
+};

package/dist/cjs/utils/hierarchicalSelection/types.js

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

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

@@ -0,0 +1,10 @@
+export * from './componentPropsProcessors';
+export * from './debounce';
+export * from './hierarchicalSelection';
+export * from './innerRef';
+export * from './isBrowser';
+export * from './copyToClipboard';
+export * from './keyboard';
+export * from './throttle';
+export * from './typeGuards';
+export * from './stopEventPropagation';

package/dist/cjs/utils/index.js

@@ -0,0 +1,26 @@
+"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("./componentPropsProcessors"), exports);
+__exportStar(require("./debounce"), exports);
+__exportStar(require("./hierarchicalSelection"), exports);
+__exportStar(require("./innerRef"), exports);
+__exportStar(require("./isBrowser"), exports);
+__exportStar(require("./copyToClipboard"), exports);
+__exportStar(require("./keyboard"), exports);
+__exportStar(require("./throttle"), exports);
+__exportStar(require("./typeGuards"), exports);
+__exportStar(require("./stopEventPropagation"), exports);

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

@@ -0,0 +1,26 @@
+/**
+ * Маркер «компонент принимает DOM-ноду своего корня через проп `innerRef`».
+ *
+ * Нужен потому, что интроспекция пропсов функционального компонента в рантайме невозможна: обёртки вроде
+ * `Popover` / `Tooltip` / `Dropdown` получают триггер как `ReactElement` и должны решить, каким каналом отдать
+ * ему reference-ноду. У `forwardRef`-компонента это `ref` (определяется через `react-is`), у обычной функции —
+ * проп `innerRef`, и узнать о его поддержке можно только по явной пометке.
+ *
+ * Ключ — `Symbol.for`, поэтому маркер общий для всех копий `@cloud-ru/ds-utils` в дереве зависимостей.
+ */
+export declare const SUPPORTS_INNER_REF: unique symbol;
+/**
+ * Помечает компонент как принимающий `innerRef`. Вызывается один раз рядом с объявлением компонента:
+ *
+ * ```tsx
+ * export function Button<T extends ElementType = 'button'>({ innerRef, ...rest }: ButtonProps<T>) { … }
+ * withInnerRefSupport(Button);
+ * ```
+ *
+ * Помечать нужно только те компоненты, которые прокидывают `innerRef` на **корневой** DOM-узел — именно его
+ * ждёт позиционирование поповера. Компоненты, у которых `innerRef` ведёт на внутренний слот (например, на
+ * нативный `input`), не помечаем.
+ */
+export declare function withInnerRefSupport<T extends object>(component: T): T;
+/** Принимает ли тип элемента DOM-ноду через проп `innerRef`. */
+export declare function supportsInnerRef(type: unknown): boolean;

package/dist/cjs/utils/innerRef.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTS_INNER_REF = void 0;
+exports.withInnerRefSupport = withInnerRefSupport;
+exports.supportsInnerRef = supportsInnerRef;
+/**
+ * Маркер «компонент принимает DOM-ноду своего корня через проп `innerRef`».
+ *
+ * Нужен потому, что интроспекция пропсов функционального компонента в рантайме невозможна: обёртки вроде
+ * `Popover` / `Tooltip` / `Dropdown` получают триггер как `ReactElement` и должны решить, каким каналом отдать
+ * ему reference-ноду. У `forwardRef`-компонента это `ref` (определяется через `react-is`), у обычной функции —
+ * проп `innerRef`, и узнать о его поддержке можно только по явной пометке.
+ *
+ * Ключ — `Symbol.for`, поэтому маркер общий для всех копий `@cloud-ru/ds-utils` в дереве зависимостей.
+ */
+exports.SUPPORTS_INNER_REF = Symbol.for('@cloud-ru/ds-supports-inner-ref');
+/**
+ * Помечает компонент как принимающий `innerRef`. Вызывается один раз рядом с объявлением компонента:
+ *
+ * ```tsx
+ * export function Button<T extends ElementType = 'button'>({ innerRef, ...rest }: ButtonProps<T>) { … }
+ * withInnerRefSupport(Button);
+ * ```
+ *
+ * Помечать нужно только те компоненты, которые прокидывают `innerRef` на **корневой** DOM-узел — именно его
+ * ждёт позиционирование поповера. Компоненты, у которых `innerRef` ведёт на внутренний слот (например, на
+ * нативный `input`), не помечаем.
+ */
+function withInnerRefSupport(component) {
+    Object.defineProperty(component, exports.SUPPORTS_INNER_REF, { value: true });
+    return component;
+}
+/** Принимает ли тип элемента DOM-ноду через проп `innerRef`. */
+function supportsInnerRef(type) {
+    return ((typeof type === 'function' || (typeof type === 'object' && type !== null)) &&
+        Boolean(type[exports.SUPPORTS_INNER_REF]));
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Функция проверки текущей среды выполнения кода,
+ * нужна для корректной работы SSR
+ * @function helper
+ */
+export declare function isBrowser(): boolean;

package/dist/cjs/utils/isBrowser.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowser = isBrowser;
+/**
+ * Функция проверки текущей среды выполнения кода,
+ * нужна для корректной работы SSR
+ * @function helper
+ */
+function isBrowser() {
+    // eslint-disable-next-line @cloud-ru/ssr-safe-react/domApi
+    return Boolean(typeof window !== 'undefined' && window.document && window.document.createElement);
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Клавиши-стрелки. Внутри компонентов с собственной клавиатурной навигацией (списки, сетка
+ * календаря, roving-кнопки) их нативное поведение — прокрутка страницы — нужно гасить, иначе
+ * событие «улетает» за компонент и скроллит документ.
+ */
+export declare const ARROW_KEYS: readonly ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"];
+/**
+ * Вертикальные стрелки. Для текстовых полей гасить нужно только их (горизонтальные `ArrowLeft` /
+ * `ArrowRight` двигают каретку — их перехватывать нельзя), тогда как в сетках/списках/roving-кнопках
+ * без текста гасятся все четыре (см. {@link ARROW_KEYS}).
+ */
+export declare const VERTICAL_ARROW_KEYS: readonly ["ArrowUp", "ArrowDown"];
+export type ArrowKey = (typeof ARROW_KEYS)[number];
+/** `true`, если клавиша — одна из стрелок навигации. */
+export declare function isArrowKey(key: string): key is ArrowKey;
+/** `true`, если клавиша — вертикальная стрелка (`ArrowUp` / `ArrowDown`). */
+export declare function isVerticalArrowKey(key: string): boolean;
+/**
+ * Гасит нативную прокрутку страницы для клавиш-стрелок: если нажата стрелка — вызывает
+ * `preventDefault()` и возвращает `true`. Использовать в начале keydown-обработчика компонента,
+ * который сам обрабатывает стрелочную навигацию.
+ *
+ * @example
+ * const handleKeyDown = (e) => {
+ *   preventScrollOnArrowKeys(e);
+ *   // …собственная навигация
+ * };
+ */
+export declare function preventScrollOnArrowKeys(event: Pick<KeyboardEvent, 'key' | 'preventDefault'>): boolean;
+/**
+ * Как {@link preventScrollOnArrowKeys}, но только для вертикальных стрелок (`ArrowUp` / `ArrowDown`).
+ * Для текстовых полей: гасит прокрутку страницы по Up/Down, не трогая горизонтальные стрелки —
+ * каретка по тексту продолжает двигаться.
+ */
+export declare function preventScrollOnVerticalArrows(event: Pick<KeyboardEvent, 'key' | 'preventDefault'>): boolean;
+/**
+ * Программный фокус без авто-прокрутки страницы к элементу (`focus({ preventScroll: true })`).
+ * Применять при перемещении фокуса по клавиатуре внутри уже видимого компонента (ячейка
+ * календаря, элемент списка), иначе браузер скроллит документ к новому фокусу.
+ */
+export declare function focusWithoutScroll(element: HTMLElement | null | undefined): void;