@cloud-ru/ds-fields 2.2.3-preview-a0540d7f.0 → 2.2.4

package/src/components/FieldSelect/utils.ts

@@ -0,0 +1,132 @@
+import { Size } from '@cloud-ru/ds-field-decorator';
+import { ItemId } from '@cloud-ru/ds-list';
+import { Appearance as TagAppearance, Size as TagSize } from '@cloud-ru/ds-tag';
+
+import { SELECTION_MODE } from './constants';
+import { FieldSelectItem, FieldSelectMultipleProps, FieldSelectProps } from './types';
+
+export const TAG_SIZE_MAP: Record<Size, TagSize> = { s: 'xs', m: 'xs', l: 's' };
+
+export type WithIdContent = { id?: ItemId; content?: unknown; disabled?: boolean; appearance?: TagAppearance };
+
+export function extractLabel(item: WithIdContent): string {
+  const { content, id } = item;
+
+  if (!content) {
+    return String(id ?? '');
+  }
+
+  if (typeof content === 'string' || typeof content === 'number') {
+    return String(content);
+  }
+
+  if (typeof content === 'object' && content !== null && 'label' in content) {
+    return String((content as { label: unknown }).label);
+  }
+
+  return String(id ?? '');
+}
+
+// Текст для поиска: лейбл (option) + caption + description — паритет с легаси `useSearch`,
+// который матчил запрос по всем трём полям контента, а не только по лейблу.
+export function extractSearchText(item: WithIdContent): string {
+  const parts = [extractLabel(item)];
+  const { content } = item;
+
+  if (content && typeof content === 'object') {
+    const c = content as { caption?: unknown; description?: unknown };
+
+    if (typeof c.caption === 'string') {
+      parts.push(c.caption);
+    }
+
+    if (typeof c.description === 'string') {
+      parts.push(c.description);
+    }
+  }
+
+  return parts.join(' ');
+}
+
+// Цвет тега выбранного значения (multiple) — паритет с легаси `option.appearance`.
+// Проверка типа нужна и при типизированном поле: items часто приходят из ответа бэкенда.
+export function extractAppearance(item?: WithIdContent): TagAppearance | undefined {
+  return typeof item?.appearance === 'string' ? item.appearance : undefined;
+}
+
+export function flatten(items: FieldSelectItem[]): WithIdContent[] {
+  const out: WithIdContent[] = [];
+
+  for (const item of items) {
+    out.push(item as WithIdContent);
+
+    if ('items' in item && Array.isArray(item.items)) {
+      out.push(...flatten(item.items as FieldSelectItem[]));
+    }
+  }
+
+  return out;
+}
+
+export function findItem(items: FieldSelectItem[], id: ItemId): WithIdContent | undefined {
+  for (const item of flatten(items)) {
+    if (item.id === id) {
+      return item;
+    }
+  }
+
+  return undefined;
+}
+
+// Subsequence-fuzzy: символы запроса должны встречаться в строке в исходном порядке.
+// Пример: query=`lge` matches `Large` (L → r → arg → e).
+export function isFuzzyMatch(haystack: string, needle: string): boolean {
+  if (!needle) {
+    return true;
+  }
+
+  let i = 0;
+
+  for (const ch of haystack) {
+    if (ch === needle[i]) {
+      i += 1;
+
+      if (i === needle.length) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+export function filterItems(items: FieldSelectItem[], query: string, fuzzy: boolean): FieldSelectItem[] {
+  if (!query) {
+    return items;
+  }
+
+  const q = query.toLowerCase();
+
+  const matches = (item: FieldSelectItem): boolean => {
+    const text = extractSearchText(item as WithIdContent).toLowerCase();
+
+    return fuzzy ? isFuzzyMatch(text, q) : text.includes(q);
+  };
+
+  const walk = (list: FieldSelectItem[]): FieldSelectItem[] =>
+    list.flatMap(item => {
+      if ('items' in item && Array.isArray(item.items)) {
+        const filteredChildren = walk(item.items as FieldSelectItem[]);
+
+        return filteredChildren.length > 0 ? [{ ...item, items: filteredChildren } as FieldSelectItem] : [];
+      }
+
+      return matches(item) ? [item] : [];
+    });
+
+  return walk(items);
+}
+
+export function isMultiple(props: FieldSelectProps): props is FieldSelectMultipleProps {
+  return props.selection === SELECTION_MODE.Multiple;
+}

package/src/components/FieldTime/FieldTime.tsx

@@ -267,7 +267,7 @@ export const FieldTime = forwardRef<HTMLInputElement, FieldTimeProps>(function F
     [onInputKeyDown, timeSeg],
   );
 
-  // value ведёт сегментный движок (keydown); нативный onChange input'а игнорируем.
+  // value ведёт сегментный движок (useSegmentedMask); нативный onChange input'а игнорируем.
   const handleInputChange = useCallback(() => undefined, []);
 
   const handleInputFocus = useCallback(
@@ -323,7 +323,7 @@ export const FieldTime = forwardRef<HTMLInputElement, FieldTimeProps>(function F
           <div className={fieldStyles.inputLine}>
             <div className={fieldStyles.inputArea}>
               <InputPrivate
-                ref={mergeRefs(ref, localRef)}
+                ref={mergeRefs(ref, localRef, timeSeg.nativeInputRef)}
                 className={fieldStyles.fieldInput}
                 value={inputValue}
                 onChange={handleInputChange}

package/src/segments/useSegmentedMask.ts

@@ -1,6 +1,19 @@
+import { useEventHandler } from '@cloud-ru/ds-utils';
 import { ClipboardEvent, KeyboardEvent, MouseEvent, RefObject, useCallback, useRef } from 'react';
 
-import { SlotMeta } from './segments';
+import { SegmentKey, SlotMeta } from './segments';
+
+const RESET_TYPED_KEYS = new Set([
+  'ArrowLeft',
+  'ArrowRight',
+  'ArrowUp',
+  'ArrowDown',
+  'Backspace',
+  'Delete',
+  'Enter',
+  'Tab',
+  'Escape',
+]);
 
 type UseSegmentedMaskParams = {
   inputRef: RefObject<HTMLInputElement | null>;
@@ -32,6 +45,7 @@ type UseSegmentedMaskParams = {
  * Сегментный ввод даты/времени (порт `useDateField` из @snack-uikit/fields). Каретка ходит по
  * сегментам (`setSelectionRange` подсвечивает текущий), цифры заполняют сегмент с авто-переходом,
  * стрелки двигают по сегментам, Backspace очищает сегмент до плейсхолдера.
+ * `nativeInputRef` передаётся в `ref` того же input'а: значение правится через нативные `beforeinput`/`input`.
  */
 export function useSegmentedMask({
   inputRef,
@@ -174,74 +188,71 @@ export function useSegmentedMask({
     [clearSlot, isValidDate, lastSlot, nextSlot, selectSlot, slots, tryToComplete],
   );
 
+  // Цифры сегмента храним отдельно от текста: по `01` в поле не отличить `1` от `0` + `1`.
+  const typedRef = useRef<{ key: SegmentKey; digits: string } | null>(null);
+  const resetTyped = useCallback(() => {
+    typedRef.current = null;
+  }, []);
+
   const typeDigit = useCallback(
     (slot: SlotMeta, key: string) => {
-      const text = getSlotText(slot);
-      const numberValue = Number(text) || 0;
-      const digit = Number(key);
-      const slotValue = parseInt(numberValue.toString() + key, 10) || 0;
-      const valueLength = slotValue.toString().length;
       const maxLength = slot.max.toString().length;
-      const isTheLastInput = /^0+$/.test(text) && maxLength === 2 && digit === 0;
-
-      if (valueLength < maxLength) {
-        if (slotValue || slotValue >= slot.min) {
-          updateSlot(slot, slotValue);
-          if (isTheLastInput) checkInputAndGoNext(slot);
-        }
-        if (slotValue * 10 > slot.max) {
-          checkInputAndGoNext(slot);
-        }
-      } else if (valueLength > maxLength) {
-        if (digit * 10 > slot.max) {
-          updateSlot(slot, key);
-          checkInputAndGoNext(slot);
-        } else if (digit || digit >= slot.min) {
-          updateSlot(slot, key);
-        }
-      } else if (slotValue <= slot.max) {
-        updateSlot(slot, slotValue);
-        checkInputAndGoNext(slot);
-      } else if (digit * 10 > slot.max) {
-        updateSlot(slot, key);
-        checkInputAndGoNext(slot);
-      } else if (digit || digit >= slot.min) {
-        updateSlot(slot, key);
+      const prev = typedRef.current?.key === slot.key ? typedRef.current.digits : '';
+      const appended = prev + key;
+      const overflow = Number(appended) > slot.max;
+      const digits = overflow ? key : appended;
+      const value = Number(digits);
+      const complete = overflow || digits.length >= maxLength || value * 10 > slot.max;
+      const accepted = value >= slot.min;
+
+      if (accepted) updateSlot(slot, value);
+
+      if (!complete) {
+        typedRef.current = { key: slot.key, digits };
+        return;
       }
+
+      typedRef.current = null;
+      if (accepted) checkInputAndGoNext(slot);
     },
-    [checkInputAndGoNext, getSlotText, updateSlot],
+    [checkInputAndGoNext, updateSlot],
   );
 
   const handleFocus = useCallback(() => {
     if (readonly || disabled) return;
+    resetTyped();
     ensureMask();
     // На фокус всегда выбираем ПЕРВЫЙ сегмент (паритет с легаси). При клике мышью `handleClick`
     // отработает следом и перевыберет сегмент под кареткой; при Tab остаётся первый.
     selectSlot(firstSlot);
-  }, [disabled, ensureMask, firstSlot, readonly, selectSlot]);
+  }, [disabled, ensureMask, firstSlot, readonly, resetTyped, selectSlot]);
 
   const handleClick = useCallback(
     (event: MouseEvent<HTMLInputElement>) => {
       if (readonly || disabled) return;
+      resetTyped();
       ensureMask();
       selectSlot(slotFromIndex(event.currentTarget.selectionStart));
     },
-    [disabled, ensureMask, readonly, selectSlot, slotFromIndex],
+    [disabled, ensureMask, readonly, resetTyped, selectSlot, slotFromIndex],
   );
 
   const handleBlur = useCallback(() => {
+    resetTyped();
     const input = inputRef.current;
     if (input && input.value === mask) {
       input.value = '';
       setValue('');
     }
-  }, [inputRef, mask, setValue]);
+  }, [inputRef, mask, resetTyped, setValue]);
 
   const handleKeyDown = useCallback(
     (event: KeyboardEvent<HTMLInputElement>) => {
       const input = inputRef.current;
       if (!input || readonly || disabled) return;
 
+      if (RESET_TYPED_KEYS.has(event.key)) resetTyped();
+
       // Tab уводит фокус из поля — не перехватываем.
       if (event.key === 'Tab') return;
 
@@ -258,8 +269,14 @@ export function useSegmentedMask({
         return;
       }
 
+      // Копирование и вставку не блокируем: правку поля перехватит beforeinput.
+      if (event.ctrlKey || event.metaKey || event.altKey) return;
+
       onEdit?.();
 
+      // Экранные клавиатуры присылают `Unidentified` вместо цифры, её данные есть только в beforeinput.
+      if (/^\d$/.test(event.key) || event.key === 'Unidentified') return;
+
       if (event.key === 'Escape') {
         event.preventDefault();
         onEscape?.();
@@ -297,11 +314,6 @@ export function useSegmentedMask({
       if (event.key === 'Enter') {
         tryToComplete();
         emit();
-        return;
-      }
-      if (/^\d$/.test(event.key)) {
-        typeDigit(slot, event.key);
-        emit();
       }
     },
     [
@@ -318,22 +330,16 @@ export function useSegmentedMask({
       onEscape,
       prevSlot,
       readonly,
+      resetTyped,
       selectSlot,
       slotFromIndex,
       tryToComplete,
-      typeDigit,
     ],
   );
 
-  // Вставка (Ctrl+V) полной строки даты/времени: вытаскиваем цифры и заполняем сегменты
-  // слева направо. Нативный onChange у поля игнорируется (движок controlled), поэтому без
-  // этого обработчика вставка не работала бы вовсе.
-  const handlePaste = useCallback(
-    (event: ClipboardEvent<HTMLInputElement>) => {
-      if (readonly || disabled) return;
-      event.preventDefault();
-      const digits = event.clipboardData.getData('text').replace(/\D/g, '');
-      if (!digits) return;
+  const fillFromDigits = useCallback(
+    (digits: string) => {
+      resetTyped();
       ensureMask();
 
       let cursor = 0;
@@ -352,10 +358,123 @@ export function useSegmentedMask({
       } else if (lastFilled) {
         selectSlot(nextSlot(lastFilled));
       }
+    },
+    [ensureMask, lastSlot, nextSlot, resetTyped, selectSlot, slots, tryToComplete, updateSlot],
+  );
+
+  const handlePaste = useCallback(
+    (event: ClipboardEvent<HTMLInputElement>) => {
+      if (readonly || disabled) return;
+      event.preventDefault();
+      const digits = event.clipboardData.getData('text').replace(/\D/g, '');
+      if (!digits) return;
+      fillFromDigits(digits);
+      emit();
+    },
+    [disabled, emit, fillFromDigits, readonly],
+  );
+
+  const applyEdit = useCallback(
+    (inputType: string, text: string) => {
+      const input = inputRef.current;
+      if (!input) return;
+      onEdit?.();
+
+      if (inputType.startsWith('delete')) {
+        resetTyped();
+        clearSlot(slotFromIndex(input.selectionStart));
+        emit();
+        return;
+      }
+
+      const digits = text.replace(/\D/g, '');
+      if (!inputType.startsWith('insert') || !digits) return;
+
+      // Автозаполнение, `fill` и drop присылают строку целиком.
+      if (text.length > 1) {
+        fillFromDigits(digits);
+      } else {
+        typeDigit(slotFromIndex(input.selectionStart), digits);
+      }
       emit();
     },
-    [disabled, emit, ensureMask, lastSlot, nextSlot, readonly, selectSlot, slots, tryToComplete, updateSlot],
+    [clearSlot, emit, fillFromDigits, inputRef, onEdit, resetTyped, slotFromIndex, typeDigit],
+  );
+
+  // Композицию IME браузер не даёт отменить — откатываем её в input.
+  const pendingEditRef = useRef<{ value: string; start: number; end: number } | null>(null);
+
+  const handleBeforeInput = useCallback(
+    (event: InputEvent) => {
+      const input = inputRef.current;
+      if (!input || readonly || disabled) return;
+      ensureMask();
+
+      if (!event.cancelable) {
+        pendingEditRef.current = { value: input.value, start: input.selectionStart ?? 0, end: input.selectionEnd ?? 0 };
+        return;
+      }
+
+      event.preventDefault();
+      applyEdit(event.inputType, event.data ?? event.dataTransfer?.getData('text') ?? '');
+    },
+    [applyEdit, disabled, ensureMask, inputRef, readonly],
+  );
+
+  const handleInput = useCallback(
+    (event: Event) => {
+      const input = inputRef.current;
+      if (!input || readonly || disabled) return;
+      const pending = pendingEditRef.current;
+      pendingEditRef.current = null;
+
+      if (pending) {
+        const inputType = event instanceof InputEvent ? event.inputType : '';
+        const inserted = input.value.slice(pending.start, input.value.length - (pending.value.length - pending.end));
+        input.value = pending.value;
+        setValue(pending.value);
+        input.setSelectionRange(pending.start, pending.end);
+        // Цифру композиции вводит её фиксация (insertText), иначе цифра запишется дважды.
+        if (!inputType.includes('Composition')) applyEdit(inputType, inserted);
+        return;
+      }
+
+      // Автозаполнение меняет значение без beforeinput.
+      const digits = input.value.replace(/\D/g, '');
+      input.value = mask;
+      setValue(mask);
+      fillFromDigits(digits);
+      emit();
+    },
+    [applyEdit, disabled, emit, fillFromDigits, inputRef, mask, readonly, setValue],
+  );
+
+  // React 18 не отдаёт `inputType` в `onBeforeInput`, поэтому слушаем нативные события.
+  const onNativeBeforeInput = useEventHandler(handleBeforeInput);
+  const onNativeInput = useEventHandler(handleInput);
+  const attachedInputRef = useRef<HTMLInputElement | null>(null);
+  const nativeInputRef = useCallback(
+    (node: HTMLInputElement | null) => {
+      /* eslint-disable @cloud-ru/ssr-safe-react/domApi -- callback-ref вызывается только в браузере */
+      attachedInputRef.current?.removeEventListener('beforeinput', onNativeBeforeInput);
+      attachedInputRef.current?.removeEventListener('input', onNativeInput);
+      attachedInputRef.current = node;
+      node?.addEventListener('beforeinput', onNativeBeforeInput);
+      node?.addEventListener('input', onNativeInput);
+      /* eslint-enable @cloud-ru/ssr-safe-react/domApi */
+    },
+    [onNativeBeforeInput, onNativeInput],
   );
 
-  return { handleKeyDown, handleClick, handleFocus, handleBlur, handlePaste, selectSlot, firstSlot, lastSlot };
+  return {
+    handleKeyDown,
+    handleClick,
+    handleFocus,
+    handleBlur,
+    handlePaste,
+    nativeInputRef,
+    selectSlot,
+    firstSlot,
+    lastSlot,
+  };
 }

package/dist/cjs/components/FieldSelect/hooks.d.ts

@@ -1,33 +0,0 @@
-import { ItemId } from '@cloud-ru/ds-list';
-import { FocusEvent, KeyboardEvent, RefObject } from 'react';
-import { FieldSelectAddCustomOptionTrigger } from './types';
-/** Результат blur: фокус остался внутри поля, ввод зафиксирован, или коммитить было нечего. */
-type CustomOptionBlurResult = 'inside' | 'committed' | 'skipped';
-type UseCustomOptionParams = {
-    allowCustomOption: boolean;
-    addCustomOptionTriggers: readonly FieldSelectAddCustomOptionTrigger[] | undefined;
-    addOptionByEnter: boolean;
-    multiple: boolean;
-    inputValue: string;
-    typing: boolean;
-    multipleValue: ItemId[];
-    commitSingle(value: ItemId | undefined): void;
-    commitMultiple(value: ItemId[]): void;
-    resetSearch(): void;
-    inputElementRef: RefObject<HTMLInputElement | null>;
-    clearButtonRef: RefObject<HTMLButtonElement | null>;
-    copyButtonRef: RefObject<HTMLButtonElement | null>;
-    footerActiveElementsRefs?: RefObject<HTMLElement>[];
-};
-/** Фиксация произвольного ввода как выбранной опции: триггеры, blur, закрытие списка. */
-export declare function useCustomOption({ allowCustomOption, addCustomOptionTriggers, addOptionByEnter, multiple, inputValue, typing, multipleValue, commitSingle, commitMultiple, resetSearch, inputElementRef, clearButtonRef, copyButtonRef, footerActiveElementsRefs, }: UseCustomOptionParams): {
-    listRef: RefObject<HTMLElement>;
-    suppressCloseCommit: () => void;
-    enableCloseCommit: () => void;
-    tryCommitOnClose: () => boolean;
-    tryCommitOnBlur: (event: FocusEvent<HTMLInputElement>) => CustomOptionBlurResult;
-    tryCommitFromKeyboard: (event: KeyboardEvent<HTMLInputElement>) => boolean;
-    handleListSingleChange: (next: ItemId | undefined) => void;
-    handleListMultipleChange: (next: ItemId[]) => void;
-};
-export {};

package/dist/cjs/components/FieldSelect/hooks.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useCustomOption = useCustomOption;
-const utils_1 = require("@cloud-ru/ds-utils");
-const react_1 = require("react");
-const constants_1 = require("./constants");
-const utils_2 = require("./utils");
-/** Фиксация произвольного ввода как выбранной опции: триггеры, blur, закрытие списка. */
-function useCustomOption({ allowCustomOption, addCustomOptionTriggers, addOptionByEnter, multiple, inputValue, typing, multipleValue, commitSingle, commitMultiple, resetSearch, inputElementRef, clearButtonRef, copyButtonRef, footerActiveElementsRefs, }) {
-    const listRef = (0, react_1.useRef)(null);
-    const skipCloseCommitRef = (0, react_1.useRef)(false);
-    const skipBlurCommitRef = (0, react_1.useRef)(false);
-    const resolvedTriggers = (0, react_1.useMemo)(() => (0, utils_2.resolveAddCustomOptionTriggers)({
-        allowCustomOption,
-        addCustomOptionTriggers,
-        addOptionByEnter,
-        defaultTriggers: multiple ? constants_1.ADD_CUSTOM_OPTION_TRIGGERS_MULTIPLE : constants_1.ADD_CUSTOM_OPTION_TRIGGERS_SINGLE,
-    }), [allowCustomOption, addCustomOptionTriggers, addOptionByEnter, multiple]);
-    const tryCommit = (0, react_1.useCallback)((trigger) => {
-        if (!typing || !(0, utils_2.shouldHandleCustomOptionTrigger)(trigger, resolvedTriggers) || inputValue === '') {
-            return false;
-        }
-        if (multiple) {
-            if (multipleValue.includes(inputValue)) {
-                resetSearch();
-            }
-            else {
-                commitMultiple([...multipleValue, inputValue]);
-            }
-        }
-        else {
-            commitSingle(inputValue);
-        }
-        return true;
-    }, [typing, resolvedTriggers, inputValue, multiple, multipleValue, commitMultiple, commitSingle, resetSearch]);
-    const suppressCloseCommit = (0, react_1.useCallback)(() => {
-        skipCloseCommitRef.current = true;
-        skipBlurCommitRef.current = true;
-    }, []);
-    const enableCloseCommit = (0, react_1.useCallback)(() => {
-        skipCloseCommitRef.current = false;
-        skipBlurCommitRef.current = false;
-    }, []);
-    const tryCommitOnClose = (0, react_1.useCallback)(() => {
-        const skipped = skipCloseCommitRef.current;
-        const shouldCommit = (0, utils_2.shouldCommitCustomOptionOnClose)({
-            skip: skipped,
-            inputElement: inputElementRef.current,
-            activeElement: (0, utils_1.isBrowser)() ? document.activeElement : null,
-        });
-        if (skipped) {
-            queueMicrotask(() => {
-                skipCloseCommitRef.current = false;
-            });
-        }
-        return shouldCommit && tryCommit(constants_1.ADD_CUSTOM_OPTION_TRIGGER.Blur);
-    }, [inputElementRef, tryCommit]);
-    const tryCommitOnBlur = (0, react_1.useCallback)((event) => {
-        if (skipBlurCommitRef.current) {
-            skipBlurCommitRef.current = false;
-            return 'skipped';
-        }
-        if ((0, utils_2.isCustomOptionBlurInsideField)(event.relatedTarget, [
-            listRef.current,
-            clearButtonRef.current,
-            copyButtonRef.current,
-            ...(footerActiveElementsRefs?.map(ref => ref.current) ?? []),
-        ])) {
-            return 'inside';
-        }
-        return tryCommit(constants_1.ADD_CUSTOM_OPTION_TRIGGER.Blur) ? 'committed' : 'skipped';
-    }, [clearButtonRef, copyButtonRef, footerActiveElementsRefs, tryCommit]);
-    const tryCommitFromKeyboard = (0, react_1.useCallback)((event) => {
-        const trigger = (0, utils_2.getCustomOptionTriggerByCode)(event.code, event.key);
-        return trigger !== undefined && tryCommit(trigger);
-    }, [tryCommit]);
-    const handleListSingleChange = (0, react_1.useCallback)((next) => {
-        skipCloseCommitRef.current = true;
-        commitSingle(next);
-    }, [commitSingle]);
-    const handleListMultipleChange = (0, react_1.useCallback)((next) => {
-        skipCloseCommitRef.current = true;
-        commitMultiple(next);
-    }, [commitMultiple]);
-    return {
-        listRef,
-        suppressCloseCommit,
-        enableCloseCommit,
-        tryCommitOnClose,
-        tryCommitOnBlur,
-        tryCommitFromKeyboard,
-        handleListSingleChange,
-        handleListMultipleChange,
-    };
-}

package/dist/cjs/components/FieldSelect/utils/customOption.d.ts

@@ -1,21 +0,0 @@
-import { FieldSelectAddCustomOptionTrigger, FieldSelectMultipleAddCustomOptionTrigger } from '../types';
-/**
- * Сопоставляет клавишу с триггером кастомной опции (`enter` / `space` / `comma`).
- * Сначала `KeyboardEvent.code`, затем `key` — если `code` пустой или не из словаря (`','` без `Comma`).
- */
-export declare function getCustomOptionTriggerByCode(code: string, key?: string): FieldSelectMultipleAddCustomOptionTrigger | undefined;
-export declare function shouldHandleCustomOptionTrigger(trigger: FieldSelectAddCustomOptionTrigger | undefined, availableTriggers: readonly FieldSelectAddCustomOptionTrigger[]): trigger is FieldSelectAddCustomOptionTrigger;
-export declare function resolveAddCustomOptionTriggers(params: {
-    allowCustomOption: boolean;
-    addCustomOptionTriggers: readonly FieldSelectAddCustomOptionTrigger[] | undefined;
-    addOptionByEnter: boolean;
-    defaultTriggers: readonly FieldSelectAddCustomOptionTrigger[];
-}): FieldSelectAddCustomOptionTrigger[];
-/** Фокус ушёл на дроплист, футер или postfix — кастомную опцию на blur фиксировать не нужно. */
-export declare function isCustomOptionBlurInsideField(relatedTarget: EventTarget | null, nodes: (Node | null | undefined)[]): boolean;
-/** Клик снаружи закрывает список, не снимая фокус с input — blur не придёт. */
-export declare function shouldCommitCustomOptionOnClose(params: {
-    skip: boolean;
-    inputElement: Element | null;
-    activeElement: Element | null;
-}): boolean;

package/dist/cjs/components/FieldSelect/utils/customOption.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCustomOptionTriggerByCode = getCustomOptionTriggerByCode;
-exports.shouldHandleCustomOptionTrigger = shouldHandleCustomOptionTrigger;
-exports.resolveAddCustomOptionTriggers = resolveAddCustomOptionTriggers;
-exports.isCustomOptionBlurInsideField = isCustomOptionBlurInsideField;
-exports.shouldCommitCustomOptionOnClose = shouldCommitCustomOptionOnClose;
-const constants_1 = require("../constants");
-/**
- * Сопоставляет клавишу с триггером кастомной опции (`enter` / `space` / `comma`).
- * Сначала `KeyboardEvent.code`, затем `key` — если `code` пустой или не из словаря (`','` без `Comma`).
- */
-function getCustomOptionTriggerByCode(code, key) {
-    switch (code) {
-        case 'Enter':
-            return constants_1.ADD_CUSTOM_OPTION_TRIGGER.Enter;
-        case 'Space':
-            return constants_1.ADD_CUSTOM_OPTION_TRIGGER.Space;
-        case 'Comma':
-            return constants_1.ADD_CUSTOM_OPTION_TRIGGER.Comma;
-        default:
-            break;
-    }
-    switch (key) {
-        case 'Enter':
-            return constants_1.ADD_CUSTOM_OPTION_TRIGGER.Enter;
-        case ' ':
-            return constants_1.ADD_CUSTOM_OPTION_TRIGGER.Space;
-        case ',':
-            return constants_1.ADD_CUSTOM_OPTION_TRIGGER.Comma;
-        default:
-            return undefined;
-    }
-}
-function shouldHandleCustomOptionTrigger(trigger, availableTriggers) {
-    return trigger !== undefined && availableTriggers.includes(trigger);
-}
-function resolveAddCustomOptionTriggers(params) {
-    if (params.allowCustomOption) {
-        const source = params.addCustomOptionTriggers !== undefined ? params.addCustomOptionTriggers : params.defaultTriggers;
-        return source.filter(trigger => params.defaultTriggers.includes(trigger));
-    }
-    if (params.addOptionByEnter) {
-        return [constants_1.ADD_CUSTOM_OPTION_TRIGGER.Enter];
-    }
-    return [];
-}
-/** Фокус ушёл на дроплист, футер или postfix — кастомную опцию на blur фиксировать не нужно. */
-function isCustomOptionBlurInsideField(relatedTarget, nodes) {
-    return relatedTarget instanceof Node && nodes.some(node => Boolean(node?.contains(relatedTarget)));
-}
-/** Клик снаружи закрывает список, не снимая фокус с input — blur не придёт. */
-function shouldCommitCustomOptionOnClose(params) {
-    return !params.skip && params.activeElement !== null && params.activeElement === params.inputElement;
-}