@infomaximum/ui-kit 0.12.12 → 0.13.1

package/dist/components/BaseSelect/BaseSelect.js

@@ -0,0 +1,360 @@
+import { jsx, jsxs, Fragment } from "@emotion/react/jsx-runtime";
+import { memo, useState, useRef, useCallback, useEffect, useMemo } from "react";
+import { getSelectDefaultStyle, getSelectSearchInputWidthStyle } from "./BaseSelect.styles.js";
+import { CloseCircleFilled, DownOutlined, BarsOutlined, SearchOutlined } from "@infomaximum/icons";
+import { isUndefined, isFunction, isNull, isNumber } from "lodash-es";
+import { useFloating, autoUpdate, offset, flip } from "@floating-ui/react";
+import { convertSelectPlacement, getLabel, getVisibleLabels } from "./BaseSelect.utils.js";
+import { useSearch } from "./hooks/useSearch.js";
+import { useCurrentValue } from "./hooks/useCurrentValue.js";
+import { SelectTag } from "./components/SelectTag/SelectTag.js";
+import { useHideElements } from "./hooks/useHideElements.js";
+import { TagPlaceholder, tagPlaceholderDataElement } from "./components/TagPlaceholder/TagPlaceholder.js";
+import { SelectOptionList } from "./components/SelectOptionList/SelectOptionList.js";
+import { createBaseSelectContext } from "./contexts/BaseSelectContext.js";
+import { useTheme } from "../../hooks/useTheme/useTheme.js";
+const BaseSelectComponent = ({
+  options = [],
+  mode = "single",
+  variant = "outlined",
+  defaultValue,
+  defaultOpen = false,
+  defaultActiveFirstOption,
+  value,
+  open,
+  placeholder,
+  dropdownMinWidth = 120,
+  dropdownMaxHeight = 414,
+  allowClear = false,
+  autoFocus,
+  prefix,
+  suffixIcon = /* @__PURE__ */ jsx(DownOutlined, {}),
+  status = "default",
+  disabled = false,
+  dropdownPrompt,
+  loading = false,
+  dropdownClassName,
+  styles,
+  dropdownMatchSelectWidth = true,
+  placement = "bottomLeft",
+  virtual = true,
+  emptyContent = "",
+  showSearch = mode === "single" ? false : true,
+  searchValue,
+  notFoundContent = "Not found",
+  optionLabelProp = "title",
+  drawer = false,
+  autoClearSearchValue = true,
+  maxTagCount,
+  maxTagTextLength,
+  maxTagPlaceholder,
+  currentSelectingIndex,
+  getCurrentSelectingValue,
+  onKeyControl,
+  getOptionByValue,
+  virtualizerEstimateSize,
+  filterOptions,
+  filterSort,
+  valuesFilter,
+  dropdownRender,
+  optionRender,
+  labelRender,
+  onBlur,
+  onChange,
+  onClear,
+  onDropdownVisibleChange,
+  onFocus,
+  onInputKeyDown,
+  onSelect,
+  getPopupContainer = () => document.body,
+  onSearch,
+  tagRender,
+  onDeselect,
+  renderDropdownItem,
+  onTagClose
+}) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const theme = useTheme();
+  const baseSelectContext = createBaseSelectContext();
+  const {
+    filteredAndSortedOptions,
+    searchInputValue,
+    searchHandle,
+    clearSearchValue
+  } = useSearch({
+    options,
+    searchValue,
+    onSearch,
+    filterSort,
+    filterOptions
+  });
+  const {
+    currentValue,
+    changeCurrentValue,
+    removeValue,
+    clearCurrentValue
+  } = useCurrentValue(mode, defaultValue, defaultActiveFirstOption, options, onDeselect);
+  const [isSelectOpen, setIsSelectOpen] = useState(defaultOpen);
+  const [isHover, setIsHover] = useState(false);
+  const isInitialMount = useRef(true);
+  const controlRef = useRef(null);
+  const inputRef = useRef(null);
+  const referenceOffsetWidth = (_a = controlRef.current) == null ? void 0 : _a.offsetWidth;
+  const {
+    refs,
+    floatingStyles
+  } = useFloating({
+    whileElementsMounted: autoUpdate,
+    placement: convertSelectPlacement(placement),
+    middleware: [offset(4), flip()]
+  });
+  const returnFocusToWrapper = useCallback(() => {
+    setTimeout(() => {
+      var _a2;
+      (_a2 = controlRef.current) == null ? void 0 : _a2.focus();
+    });
+  }, []);
+  const returnFocusToInput = useCallback(() => {
+    setTimeout(() => {
+      var _a2;
+      (_a2 = inputRef.current) == null ? void 0 : _a2.focus();
+    });
+  }, []);
+  useEffect(() => {
+    if (!isInitialMount.current) {
+      const options2 = currentValue.reduce((acc, value2) => {
+        const option = getOptionByValue(value2);
+        if (isUndefined(option)) {
+          return acc;
+        }
+        return [...acc, option];
+      }, []);
+      onChange == null ? void 0 : onChange(currentValue, options2);
+    }
+  }, [currentValue, getOptionByValue, onChange]);
+  useEffect(() => {
+    if (isInitialMount.current) {
+      isInitialMount.current = false;
+    } else {
+      onDropdownVisibleChange == null ? void 0 : onDropdownVisibleChange();
+    }
+  }, [isSelectOpen, onDropdownVisibleChange]);
+  const activeValues = useMemo(() => {
+    return Array.isArray(value) ? value : isUndefined(value) ? currentValue : [value];
+  }, [currentValue, value]);
+  const selectDefaultStyle = getSelectDefaultStyle({
+    status,
+    disabled,
+    variant,
+    multiple: mode === "multiple",
+    isHover,
+    maxTagCount,
+    withPrefix: !!prefix,
+    isEmpty: activeValues.length === 0
+  });
+  const filteredActiveValues = useMemo(() => {
+    return isFunction(valuesFilter) ? valuesFilter(activeValues) : activeValues;
+  }, [activeValues, valuesFilter]);
+  const {
+    containerRef,
+    isItemHidden
+  } = useHideElements(filteredActiveValues, theme.spaceXS, inputRef, maxTagCount);
+  const currentLabel = getLabel(filteredActiveValues, getOptionByValue, optionLabelProp);
+  const withDrawer = mode === "multiple" && drawer;
+  const withAutoClear = mode === "single" || autoClearSearchValue;
+  const clickHandle = () => {
+    if (disabled) {
+      return;
+    }
+    setIsSelectOpen((prev) => !prev);
+  };
+  const changeHandle = useCallback((value2) => {
+    changeCurrentValue(value2);
+    if (Array.isArray(value2)) {
+      return;
+    }
+    const option = getOptionByValue(value2);
+    if (withAutoClear) {
+      clearSearchValue();
+    }
+    if (option) {
+      onSelect == null ? void 0 : onSelect(value2, option);
+    }
+  }, [changeCurrentValue, clearSearchValue, getOptionByValue, onSelect, withAutoClear]);
+  const closeOptionList = useCallback(() => {
+    setIsSelectOpen(false);
+  }, []);
+  const blurHandle = (e) => {
+    var _a2;
+    const isFocusOnOptionList = (_a2 = refs.floating.current) == null ? void 0 : _a2.contains(e.relatedTarget);
+    const isFocusOnSearchInput = !isNull(inputRef.current) && e.relatedTarget === inputRef.current;
+    const isFocusOnControl = e.relatedTarget === controlRef.current;
+    if (isFocusOnOptionList || isFocusOnSearchInput || isFocusOnControl) {
+      if (showSearch) {
+        returnFocusToInput();
+      } else {
+        returnFocusToWrapper();
+      }
+      return;
+    }
+    onBlur == null ? void 0 : onBlur(e);
+    clearSearchValue();
+    closeOptionList();
+  };
+  const clearSelect = useCallback((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    clearCurrentValue();
+    onClear == null ? void 0 : onClear();
+  }, [clearCurrentValue, onClear]);
+  const keyDownHandler = (e) => {
+    if (e.key === "Enter") {
+      if (isSelectOpen) {
+        const value2 = getCurrentSelectingValue();
+        if (!value2) {
+          return;
+        }
+        if (currentValue.includes(value2)) {
+          removeValue(value2);
+        } else {
+          changeCurrentValue(value2);
+        }
+        if (withAutoClear) {
+          clearSearchValue();
+        }
+      }
+      clickHandle();
+    }
+    setIsSelectOpen(true);
+    onKeyControl(e);
+    onInputKeyDown == null ? void 0 : onInputKeyDown(e);
+  };
+  const mouseOverHandle = () => {
+    setIsHover(true);
+  };
+  const mouseOutHandle = () => {
+    setIsHover(false);
+  };
+  const focusHandle = (e) => {
+    onFocus == null ? void 0 : onFocus(e);
+    if (!showSearch) {
+      return;
+    }
+    returnFocusToInput();
+  };
+  const renderTagPlaceholder = (hiddenElementsCounter) => {
+    if (isUndefined(maxTagPlaceholder)) {
+      return /* @__PURE__ */ jsx(TagPlaceholder, { hiddenElementsCounter });
+    }
+    if (!isFunction(maxTagPlaceholder)) {
+      return /* @__PURE__ */ jsx("span", { "data-element": tagPlaceholderDataElement, children: maxTagPlaceholder });
+    }
+    const hiddenElements = currentValue.reduce((acc, value2) => {
+      const isHidden = isItemHidden.get(value2);
+      const option = getOptionByValue(value2);
+      if (!isHidden || isUndefined(option)) {
+        return acc;
+      }
+      acc.push(option);
+      return acc;
+    }, []);
+    return /* @__PURE__ */ jsx("span", { "data-element": tagPlaceholderDataElement, children: maxTagPlaceholder(hiddenElements) });
+  };
+  const renderLabel = (values, currentLabel2) => {
+    const visibleLabels = getVisibleLabels(currentLabel2, maxTagCount);
+    const label = visibleLabels.map((label2, index) => {
+      const value2 = values[index];
+      if (isFunction(labelRender)) {
+        return labelRender({
+          label: label2,
+          value: value2
+        });
+      }
+      if (mode === "single") {
+        return label2;
+      }
+      if (isFunction(tagRender)) {
+        return tagRender(label2);
+      }
+      const isHidden = !!isItemHidden.get(value2);
+      return /* @__PURE__ */ jsx(SelectTag, { value: value2, label: label2, removeValue, maxTagTextLength, isBorderless: variant === "borderless", isError: status === "error", disabled, isHidden, onTagClose }, value2 == null ? void 0 : value2.toString());
+    });
+    const hiddenElementsCounter = isNumber(maxTagCount) ? isItemHidden.size - maxTagCount : Array.from(isItemHidden.values()).reduce((acc, isHidden) => isHidden ? acc + 1 : acc, 0);
+    const withTagPlaceholder = !isUndefined(maxTagCount) && mode === "multiple" && hiddenElementsCounter > 0;
+    if (label.length === 0) {
+      return null;
+    }
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      label,
+      withTagPlaceholder && renderTagPlaceholder(hiddenElementsCounter)
+    ] });
+  };
+  const renderSuffix = () => {
+    var _a2;
+    if (withDrawer) {
+      return /* @__PURE__ */ jsx(BarsOutlined, { onClick: clickHandle, css: [selectDefaultStyle.drawerIcon(theme), (_a2 = styles == null ? void 0 : styles.drawerIcon) == null ? void 0 : _a2.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:renderSuffix;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx"],"names":[],"mappings":"AA4YU","file":"/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx","sourcesContent":["import {\n  type FocusEvent,\n  type KeyboardEvent,\n  memo,\n  type MouseEvent,\n  type PropsWithChildren,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport { getSelectDefaultStyle, getSelectSearchInputWidthStyle } from \"./BaseSelect.styles\";\nimport { useTheme } from \"hooks/useTheme\";\nimport { BarsOutlined, CloseCircleFilled, DownOutlined, SearchOutlined } from \"@infomaximum/icons\";\nimport { isFunction, isNull, isNumber, isUndefined } from \"lodash-es\";\nimport { autoUpdate, flip, offset, useFloating } from \"@floating-ui/react\";\nimport { convertSelectPlacement, getLabel, getVisibleLabels } from \"./BaseSelect.utils\";\nimport { useSearch } from \"./hooks/useSearch\";\nimport { useCurrentValue } from \"./hooks/useCurrentValue\";\nimport { SelectTag } from \"./components/SelectTag/SelectTag\";\nimport { useHideElements } from \"./hooks/useHideElements\";\nimport {\n  TagPlaceholder,\n  tagPlaceholderDataElement,\n} from \"./components/TagPlaceholder/TagPlaceholder\";\nimport type { BaseSelectOptionInterface, BaseSelectProps } from \"./BaseSelect.types\";\nimport { SelectOptionList } from \"./components/SelectOptionList/SelectOptionList\";\nimport { createBaseSelectContext, type BaseSelectContextShape } from \"./contexts/BaseSelectContext\";\n\nconst BaseSelectComponent = <Option extends BaseSelectOptionInterface<OptionValue>, OptionValue>({\n  options = [],\n  mode = \"single\",\n  variant = \"outlined\",\n  defaultValue,\n  defaultOpen = false,\n  defaultActiveFirstOption,\n  value,\n  open,\n  placeholder,\n  dropdownMinWidth = 120,\n  dropdownMaxHeight = 414,\n  allowClear = false,\n  autoFocus,\n  prefix,\n  suffixIcon = <DownOutlined />,\n  status = \"default\",\n  disabled = false,\n  dropdownPrompt,\n  loading = false,\n  dropdownClassName,\n  styles,\n  dropdownMatchSelectWidth = true,\n  placement = \"bottomLeft\",\n  virtual = true,\n  emptyContent = \"\",\n  showSearch = mode === \"single\" ? false : true,\n  searchValue,\n  notFoundContent = \"Not found\",\n  optionLabelProp = \"title\",\n  drawer = false,\n  autoClearSearchValue = true,\n  maxTagCount,\n  maxTagTextLength,\n  maxTagPlaceholder,\n  currentSelectingIndex,\n  getCurrentSelectingValue,\n  onKeyControl,\n  getOptionByValue,\n  virtualizerEstimateSize,\n  filterOptions,\n  filterSort,\n  valuesFilter,\n  dropdownRender,\n  optionRender,\n  labelRender,\n  onBlur,\n  onChange,\n  onClear,\n  onDropdownVisibleChange,\n  onFocus,\n  onInputKeyDown,\n  onSelect,\n  getPopupContainer = () => document.body,\n  onSearch,\n  tagRender,\n  onDeselect,\n  renderDropdownItem,\n  onTagClose,\n}: PropsWithChildren<BaseSelectProps<Option, OptionValue>>) => {\n  const theme = useTheme();\n  const baseSelectContext = createBaseSelectContext<OptionValue>();\n\n  const { filteredAndSortedOptions, searchInputValue, searchHandle, clearSearchValue } = useSearch<\n    Option,\n    OptionValue\n  >({\n    options,\n    searchValue,\n    onSearch,\n    filterSort,\n    filterOptions,\n  });\n\n  const { currentValue, changeCurrentValue, removeValue, clearCurrentValue } = useCurrentValue(\n    mode,\n    defaultValue,\n    defaultActiveFirstOption,\n    options,\n    onDeselect\n  );\n\n  const [isSelectOpen, setIsSelectOpen] = useState(defaultOpen);\n  const [isHover, setIsHover] = useState(false);\n\n  const isInitialMount = useRef(true);\n  const controlRef = useRef<HTMLSpanElement | null>(null);\n  const inputRef = useRef<HTMLInputElement | null>(null);\n\n  const referenceOffsetWidth = controlRef.current?.offsetWidth;\n\n  const { refs, floatingStyles } = useFloating<HTMLSpanElement>({\n    whileElementsMounted: autoUpdate,\n    placement: convertSelectPlacement(placement),\n    middleware: [offset(4), flip()],\n  });\n\n  const returnFocusToWrapper = useCallback(() => {\n    setTimeout(() => {\n      controlRef.current?.focus();\n    });\n  }, []);\n\n  const returnFocusToInput = useCallback(() => {\n    setTimeout(() => {\n      inputRef.current?.focus();\n    });\n  }, []);\n\n  useEffect(() => {\n    if (!isInitialMount.current) {\n      const options = currentValue.reduce((acc: Option[], value) => {\n        const option = getOptionByValue(value);\n\n        if (isUndefined(option)) {\n          return acc;\n        }\n\n        return [...acc, option];\n      }, []);\n\n      onChange?.(currentValue, options);\n    }\n  }, [currentValue, getOptionByValue, onChange]);\n\n  useEffect(() => {\n    if (isInitialMount.current) {\n      isInitialMount.current = false;\n    } else {\n      onDropdownVisibleChange?.();\n    }\n  }, [isSelectOpen, onDropdownVisibleChange]);\n\n  const activeValues = useMemo(() => {\n    return Array.isArray(value) ? value : isUndefined(value) ? currentValue : [value];\n  }, [currentValue, value]);\n\n  const selectDefaultStyle = getSelectDefaultStyle({\n    status,\n    disabled,\n    variant,\n    multiple: mode === \"multiple\",\n    isHover,\n    maxTagCount,\n    withPrefix: !!prefix,\n    isEmpty: activeValues.length === 0,\n  });\n\n  const filteredActiveValues = useMemo(() => {\n    return isFunction(valuesFilter) ? valuesFilter(activeValues) : activeValues;\n  }, [activeValues, valuesFilter]);\n\n  const { containerRef, isItemHidden } = useHideElements(\n    filteredActiveValues,\n    theme.spaceXS,\n    inputRef,\n    maxTagCount\n  );\n\n  const currentLabel = getLabel<Option, OptionValue>(\n    filteredActiveValues,\n    getOptionByValue,\n    optionLabelProp\n  );\n\n  const withDrawer = mode === \"multiple\" && drawer;\n  const withAutoClear = mode === \"single\" || autoClearSearchValue;\n\n  const clickHandle = () => {\n    if (disabled) {\n      return;\n    }\n\n    setIsSelectOpen((prev) => !prev);\n  };\n\n  const changeHandle = useCallback(\n    (value: OptionValue | OptionValue[]) => {\n      changeCurrentValue(value);\n\n      if (Array.isArray(value)) {\n        return;\n      }\n\n      const option = getOptionByValue(value);\n\n      if (withAutoClear) {\n        clearSearchValue();\n      }\n\n      if (option) {\n        onSelect?.(value, option);\n      }\n    },\n    [changeCurrentValue, clearSearchValue, getOptionByValue, onSelect, withAutoClear]\n  );\n\n  const closeOptionList = useCallback(() => {\n    setIsSelectOpen(false);\n  }, []);\n\n  const blurHandle = (e: FocusEvent) => {\n    const isFocusOnOptionList = refs.floating.current?.contains(e.relatedTarget);\n    const isFocusOnSearchInput = !isNull(inputRef.current) && e.relatedTarget === inputRef.current;\n    const isFocusOnControl = e.relatedTarget === controlRef.current;\n\n    if (isFocusOnOptionList || isFocusOnSearchInput || isFocusOnControl) {\n      if (showSearch) {\n        returnFocusToInput();\n      } else {\n        returnFocusToWrapper();\n      }\n\n      return;\n    }\n\n    onBlur?.(e);\n    clearSearchValue();\n    closeOptionList();\n  };\n\n  const clearSelect = useCallback(\n    (e: MouseEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n\n      clearCurrentValue();\n      onClear?.();\n    },\n    [clearCurrentValue, onClear]\n  );\n\n  const keyDownHandler = (e: KeyboardEvent) => {\n    if (e.key === \"Enter\") {\n      if (isSelectOpen) {\n        const value = getCurrentSelectingValue();\n\n        if (!value) {\n          return;\n        }\n\n        if (currentValue.includes(value)) {\n          removeValue(value);\n        } else {\n          changeCurrentValue(value);\n        }\n\n        if (withAutoClear) {\n          clearSearchValue();\n        }\n      }\n\n      clickHandle();\n    }\n\n    setIsSelectOpen(true);\n\n    onKeyControl(e);\n    onInputKeyDown?.(e);\n  };\n\n  const mouseOverHandle = () => {\n    setIsHover(true);\n  };\n\n  const mouseOutHandle = () => {\n    setIsHover(false);\n  };\n\n  const focusHandle = (e: FocusEvent) => {\n    onFocus?.(e);\n\n    if (!showSearch) {\n      return;\n    }\n\n    returnFocusToInput();\n  };\n\n  const renderTagPlaceholder = (hiddenElementsCounter: number) => {\n    if (isUndefined(maxTagPlaceholder)) {\n      return <TagPlaceholder hiddenElementsCounter={hiddenElementsCounter} />;\n    }\n\n    if (!isFunction(maxTagPlaceholder)) {\n      return <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder}</span>;\n    }\n\n    const hiddenElements = currentValue.reduce((acc: Option[], value) => {\n      const isHidden = isItemHidden.get(value);\n      const option = getOptionByValue(value);\n\n      if (!isHidden || isUndefined(option)) {\n        return acc;\n      }\n\n      acc.push(option);\n\n      return acc;\n    }, []);\n\n    return (\n      <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder(hiddenElements)}</span>\n    );\n  };\n\n  const renderLabel = (values: OptionValue[], currentLabel: string[]) => {\n    const visibleLabels = getVisibleLabels(currentLabel, maxTagCount);\n\n    const label = visibleLabels.map((label, index) => {\n      const value = values[index] as OptionValue;\n\n      if (isFunction(labelRender)) {\n        return labelRender({ label, value });\n      }\n\n      if (mode === \"single\") {\n        return label;\n      }\n\n      if (isFunction(tagRender)) {\n        return tagRender(label);\n      }\n\n      const isHidden = !!isItemHidden.get(value);\n\n      return (\n        <SelectTag<OptionValue>\n          value={value}\n          label={label}\n          removeValue={removeValue}\n          maxTagTextLength={maxTagTextLength}\n          isBorderless={variant === \"borderless\"}\n          isError={status === \"error\"}\n          disabled={disabled}\n          isHidden={isHidden}\n          onTagClose={onTagClose}\n          key={value?.toString()}\n        />\n      );\n    });\n\n    const hiddenElementsCounter = isNumber(maxTagCount)\n      ? isItemHidden.size - maxTagCount\n      : Array.from(isItemHidden.values()).reduce((acc, isHidden) => (isHidden ? acc + 1 : acc), 0);\n\n    const withTagPlaceholder =\n      !isUndefined(maxTagCount) && mode === \"multiple\" && hiddenElementsCounter > 0;\n\n    if (label.length === 0) {\n      return null;\n    }\n\n    return (\n      <>\n        {label}\n        {withTagPlaceholder && renderTagPlaceholder(hiddenElementsCounter)}\n      </>\n    );\n  };\n\n  const renderSuffix = () => {\n    if (withDrawer) {\n      return (\n        <BarsOutlined\n          onClick={clickHandle}\n          css={[selectDefaultStyle.drawerIcon(theme), styles?.drawerIcon?.(theme)]}\n        />\n      );\n    }\n\n    if (showSearch && isSelectOpen) {\n      return <SearchOutlined />;\n    }\n\n    return suffixIcon;\n  };\n\n  const renderPlaceholder = () => (\n    <span css={[selectDefaultStyle.placeholder(theme), styles?.placeholder?.(theme)]}>\n      {placeholder}\n    </span>\n  );\n\n  const withClearButton = allowClear && !!filteredActiveValues.length;\n\n  const inputValue =\n    mode === \"multiple\" || isSelectOpen\n      ? (searchValue ?? searchInputValue)\n      : currentLabel[0]?.toString();\n\n  const isEmpty = filteredActiveValues.length === 0;\n  const singleModPlaceholder = currentLabel[0] ?? placeholder ?? \"\";\n  const multipleModPlaceholder = isEmpty ? placeholder : undefined;\n\n  const searchInputPlaceholder = mode === \"single\" ? singleModPlaceholder : multipleModPlaceholder;\n\n  const lettersNumber = (inputValue?.length ?? 0) + 1;\n\n  const hasIconPrefix = typeof prefix === \"object\";\n\n  const contextValue: BaseSelectContextShape<OptionValue> = {\n    currentValue: activeValues,\n    showOptionList: open ?? isSelectOpen,\n    setValue: changeHandle,\n    closeOptionList,\n    dropdownMinWidth,\n    dropdownMaxHeight,\n    dropdownPrompt,\n    loading,\n    dropdownClassName,\n    dropdownRender,\n    dropdownMatchSelectWidth,\n    referenceOffsetWidth,\n    floatingStyles,\n    setFloating: refs.setFloating,\n    floatingRef: refs.floating,\n    getPopupContainer,\n    virtual,\n    currentSelectingIndex,\n    emptyContent,\n    notFoundContent,\n    searchValue: searchValue ?? searchInputValue,\n    showSearch,\n    mode,\n    removeValue,\n    isItemHidden,\n    getCurrentSelectingValue,\n  };\n\n  return (\n    <baseSelectContext.Provider value={contextValue}>\n      <span\n        css={[selectDefaultStyle.wrapper(theme), styles?.wrapper?.(theme)]}\n        tabIndex={1}\n        onKeyDown={keyDownHandler}\n        onMouseOver={mouseOverHandle}\n        onMouseOut={mouseOutHandle}\n        onFocus={focusHandle}\n        onBlur={blurHandle}\n        autoFocus={autoFocus}\n        ref={controlRef}\n      >\n        <span\n          css={[selectDefaultStyle.body(theme), styles?.body?.(theme)]}\n          onClick={!withDrawer ? clickHandle : undefined}\n          ref={refs.setReference}\n        >\n          <span\n            css={[selectDefaultStyle.prefixAndContent(theme), styles?.prefixAndContent?.(theme)]}\n          >\n            {prefix && (\n              <span\n                css={[selectDefaultStyle.prefix(hasIconPrefix)(theme), styles?.prefix?.(theme)]}\n              >\n                {prefix}\n              </span>\n            )}\n\n            {showSearch ? (\n              <span ref={containerRef} css={selectDefaultStyle.content(theme)}>\n                {mode === \"multiple\" && renderLabel(filteredActiveValues, currentLabel)}\n                <input\n                  css={selectDefaultStyle.searchInput(theme)}\n                  value={inputValue ?? \"\"}\n                  onChange={searchHandle}\n                  placeholder={searchInputPlaceholder?.toString()}\n                  ref={inputRef}\n                  disabled={disabled}\n                  style={getSelectSearchInputWidthStyle(\n                    mode === \"multiple\",\n                    isEmpty,\n                    lettersNumber\n                  )}\n                  data-element=\"search-input\"\n                />\n              </span>\n            ) : (\n              <span\n                ref={containerRef}\n                css={[selectDefaultStyle.content(theme), styles?.content?.(theme)]}\n              >\n                {renderLabel(filteredActiveValues, currentLabel) ?? renderPlaceholder()}\n              </span>\n            )}\n          </span>\n\n          {withClearButton && (\n            <CloseCircleFilled\n              className=\"clean-button\"\n              onClick={clearSelect}\n              css={[selectDefaultStyle.cleanIcon(theme), styles?.cleanIcon?.(theme)]}\n              data-element=\"clean-button\"\n            />\n          )}\n          <span css={[selectDefaultStyle.suffixIcon(theme), styles?.suffixIcon?.(theme)]}>\n            {renderSuffix()}\n          </span>\n        </span>\n\n        <SelectOptionList<Option, OptionValue>\n          options={filteredAndSortedOptions}\n          renderDropdownItem={renderDropdownItem}\n          optionRender={optionRender}\n          virtualizerEstimateSize={virtualizerEstimateSize}\n          styles={styles?.dropdownStyle}\n        />\n      </span>\n    </baseSelectContext.Provider>\n  );\n};\n\nexport const BaseSelect = memo(BaseSelectComponent) as typeof BaseSelectComponent;\n"]} */"] });
+    }
+    if (showSearch && isSelectOpen) {
+      return /* @__PURE__ */ jsx(SearchOutlined, {});
+    }
+    return suffixIcon;
+  };
+  const renderPlaceholder = () => {
+    var _a2;
+    return /* @__PURE__ */ jsx("span", { css: [selectDefaultStyle.placeholder(theme), (_a2 = styles == null ? void 0 : styles.placeholder) == null ? void 0 : _a2.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:renderPlaceholder;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx"],"names":[],"mappings":"AAyZU","file":"/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx","sourcesContent":["import {\n  type FocusEvent,\n  type KeyboardEvent,\n  memo,\n  type MouseEvent,\n  type PropsWithChildren,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport { getSelectDefaultStyle, getSelectSearchInputWidthStyle } from \"./BaseSelect.styles\";\nimport { useTheme } from \"hooks/useTheme\";\nimport { BarsOutlined, CloseCircleFilled, DownOutlined, SearchOutlined } from \"@infomaximum/icons\";\nimport { isFunction, isNull, isNumber, isUndefined } from \"lodash-es\";\nimport { autoUpdate, flip, offset, useFloating } from \"@floating-ui/react\";\nimport { convertSelectPlacement, getLabel, getVisibleLabels } from \"./BaseSelect.utils\";\nimport { useSearch } from \"./hooks/useSearch\";\nimport { useCurrentValue } from \"./hooks/useCurrentValue\";\nimport { SelectTag } from \"./components/SelectTag/SelectTag\";\nimport { useHideElements } from \"./hooks/useHideElements\";\nimport {\n  TagPlaceholder,\n  tagPlaceholderDataElement,\n} from \"./components/TagPlaceholder/TagPlaceholder\";\nimport type { BaseSelectOptionInterface, BaseSelectProps } from \"./BaseSelect.types\";\nimport { SelectOptionList } from \"./components/SelectOptionList/SelectOptionList\";\nimport { createBaseSelectContext, type BaseSelectContextShape } from \"./contexts/BaseSelectContext\";\n\nconst BaseSelectComponent = <Option extends BaseSelectOptionInterface<OptionValue>, OptionValue>({\n  options = [],\n  mode = \"single\",\n  variant = \"outlined\",\n  defaultValue,\n  defaultOpen = false,\n  defaultActiveFirstOption,\n  value,\n  open,\n  placeholder,\n  dropdownMinWidth = 120,\n  dropdownMaxHeight = 414,\n  allowClear = false,\n  autoFocus,\n  prefix,\n  suffixIcon = <DownOutlined />,\n  status = \"default\",\n  disabled = false,\n  dropdownPrompt,\n  loading = false,\n  dropdownClassName,\n  styles,\n  dropdownMatchSelectWidth = true,\n  placement = \"bottomLeft\",\n  virtual = true,\n  emptyContent = \"\",\n  showSearch = mode === \"single\" ? false : true,\n  searchValue,\n  notFoundContent = \"Not found\",\n  optionLabelProp = \"title\",\n  drawer = false,\n  autoClearSearchValue = true,\n  maxTagCount,\n  maxTagTextLength,\n  maxTagPlaceholder,\n  currentSelectingIndex,\n  getCurrentSelectingValue,\n  onKeyControl,\n  getOptionByValue,\n  virtualizerEstimateSize,\n  filterOptions,\n  filterSort,\n  valuesFilter,\n  dropdownRender,\n  optionRender,\n  labelRender,\n  onBlur,\n  onChange,\n  onClear,\n  onDropdownVisibleChange,\n  onFocus,\n  onInputKeyDown,\n  onSelect,\n  getPopupContainer = () => document.body,\n  onSearch,\n  tagRender,\n  onDeselect,\n  renderDropdownItem,\n  onTagClose,\n}: PropsWithChildren<BaseSelectProps<Option, OptionValue>>) => {\n  const theme = useTheme();\n  const baseSelectContext = createBaseSelectContext<OptionValue>();\n\n  const { filteredAndSortedOptions, searchInputValue, searchHandle, clearSearchValue } = useSearch<\n    Option,\n    OptionValue\n  >({\n    options,\n    searchValue,\n    onSearch,\n    filterSort,\n    filterOptions,\n  });\n\n  const { currentValue, changeCurrentValue, removeValue, clearCurrentValue } = useCurrentValue(\n    mode,\n    defaultValue,\n    defaultActiveFirstOption,\n    options,\n    onDeselect\n  );\n\n  const [isSelectOpen, setIsSelectOpen] = useState(defaultOpen);\n  const [isHover, setIsHover] = useState(false);\n\n  const isInitialMount = useRef(true);\n  const controlRef = useRef<HTMLSpanElement | null>(null);\n  const inputRef = useRef<HTMLInputElement | null>(null);\n\n  const referenceOffsetWidth = controlRef.current?.offsetWidth;\n\n  const { refs, floatingStyles } = useFloating<HTMLSpanElement>({\n    whileElementsMounted: autoUpdate,\n    placement: convertSelectPlacement(placement),\n    middleware: [offset(4), flip()],\n  });\n\n  const returnFocusToWrapper = useCallback(() => {\n    setTimeout(() => {\n      controlRef.current?.focus();\n    });\n  }, []);\n\n  const returnFocusToInput = useCallback(() => {\n    setTimeout(() => {\n      inputRef.current?.focus();\n    });\n  }, []);\n\n  useEffect(() => {\n    if (!isInitialMount.current) {\n      const options = currentValue.reduce((acc: Option[], value) => {\n        const option = getOptionByValue(value);\n\n        if (isUndefined(option)) {\n          return acc;\n        }\n\n        return [...acc, option];\n      }, []);\n\n      onChange?.(currentValue, options);\n    }\n  }, [currentValue, getOptionByValue, onChange]);\n\n  useEffect(() => {\n    if (isInitialMount.current) {\n      isInitialMount.current = false;\n    } else {\n      onDropdownVisibleChange?.();\n    }\n  }, [isSelectOpen, onDropdownVisibleChange]);\n\n  const activeValues = useMemo(() => {\n    return Array.isArray(value) ? value : isUndefined(value) ? currentValue : [value];\n  }, [currentValue, value]);\n\n  const selectDefaultStyle = getSelectDefaultStyle({\n    status,\n    disabled,\n    variant,\n    multiple: mode === \"multiple\",\n    isHover,\n    maxTagCount,\n    withPrefix: !!prefix,\n    isEmpty: activeValues.length === 0,\n  });\n\n  const filteredActiveValues = useMemo(() => {\n    return isFunction(valuesFilter) ? valuesFilter(activeValues) : activeValues;\n  }, [activeValues, valuesFilter]);\n\n  const { containerRef, isItemHidden } = useHideElements(\n    filteredActiveValues,\n    theme.spaceXS,\n    inputRef,\n    maxTagCount\n  );\n\n  const currentLabel = getLabel<Option, OptionValue>(\n    filteredActiveValues,\n    getOptionByValue,\n    optionLabelProp\n  );\n\n  const withDrawer = mode === \"multiple\" && drawer;\n  const withAutoClear = mode === \"single\" || autoClearSearchValue;\n\n  const clickHandle = () => {\n    if (disabled) {\n      return;\n    }\n\n    setIsSelectOpen((prev) => !prev);\n  };\n\n  const changeHandle = useCallback(\n    (value: OptionValue | OptionValue[]) => {\n      changeCurrentValue(value);\n\n      if (Array.isArray(value)) {\n        return;\n      }\n\n      const option = getOptionByValue(value);\n\n      if (withAutoClear) {\n        clearSearchValue();\n      }\n\n      if (option) {\n        onSelect?.(value, option);\n      }\n    },\n    [changeCurrentValue, clearSearchValue, getOptionByValue, onSelect, withAutoClear]\n  );\n\n  const closeOptionList = useCallback(() => {\n    setIsSelectOpen(false);\n  }, []);\n\n  const blurHandle = (e: FocusEvent) => {\n    const isFocusOnOptionList = refs.floating.current?.contains(e.relatedTarget);\n    const isFocusOnSearchInput = !isNull(inputRef.current) && e.relatedTarget === inputRef.current;\n    const isFocusOnControl = e.relatedTarget === controlRef.current;\n\n    if (isFocusOnOptionList || isFocusOnSearchInput || isFocusOnControl) {\n      if (showSearch) {\n        returnFocusToInput();\n      } else {\n        returnFocusToWrapper();\n      }\n\n      return;\n    }\n\n    onBlur?.(e);\n    clearSearchValue();\n    closeOptionList();\n  };\n\n  const clearSelect = useCallback(\n    (e: MouseEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n\n      clearCurrentValue();\n      onClear?.();\n    },\n    [clearCurrentValue, onClear]\n  );\n\n  const keyDownHandler = (e: KeyboardEvent) => {\n    if (e.key === \"Enter\") {\n      if (isSelectOpen) {\n        const value = getCurrentSelectingValue();\n\n        if (!value) {\n          return;\n        }\n\n        if (currentValue.includes(value)) {\n          removeValue(value);\n        } else {\n          changeCurrentValue(value);\n        }\n\n        if (withAutoClear) {\n          clearSearchValue();\n        }\n      }\n\n      clickHandle();\n    }\n\n    setIsSelectOpen(true);\n\n    onKeyControl(e);\n    onInputKeyDown?.(e);\n  };\n\n  const mouseOverHandle = () => {\n    setIsHover(true);\n  };\n\n  const mouseOutHandle = () => {\n    setIsHover(false);\n  };\n\n  const focusHandle = (e: FocusEvent) => {\n    onFocus?.(e);\n\n    if (!showSearch) {\n      return;\n    }\n\n    returnFocusToInput();\n  };\n\n  const renderTagPlaceholder = (hiddenElementsCounter: number) => {\n    if (isUndefined(maxTagPlaceholder)) {\n      return <TagPlaceholder hiddenElementsCounter={hiddenElementsCounter} />;\n    }\n\n    if (!isFunction(maxTagPlaceholder)) {\n      return <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder}</span>;\n    }\n\n    const hiddenElements = currentValue.reduce((acc: Option[], value) => {\n      const isHidden = isItemHidden.get(value);\n      const option = getOptionByValue(value);\n\n      if (!isHidden || isUndefined(option)) {\n        return acc;\n      }\n\n      acc.push(option);\n\n      return acc;\n    }, []);\n\n    return (\n      <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder(hiddenElements)}</span>\n    );\n  };\n\n  const renderLabel = (values: OptionValue[], currentLabel: string[]) => {\n    const visibleLabels = getVisibleLabels(currentLabel, maxTagCount);\n\n    const label = visibleLabels.map((label, index) => {\n      const value = values[index] as OptionValue;\n\n      if (isFunction(labelRender)) {\n        return labelRender({ label, value });\n      }\n\n      if (mode === \"single\") {\n        return label;\n      }\n\n      if (isFunction(tagRender)) {\n        return tagRender(label);\n      }\n\n      const isHidden = !!isItemHidden.get(value);\n\n      return (\n        <SelectTag<OptionValue>\n          value={value}\n          label={label}\n          removeValue={removeValue}\n          maxTagTextLength={maxTagTextLength}\n          isBorderless={variant === \"borderless\"}\n          isError={status === \"error\"}\n          disabled={disabled}\n          isHidden={isHidden}\n          onTagClose={onTagClose}\n          key={value?.toString()}\n        />\n      );\n    });\n\n    const hiddenElementsCounter = isNumber(maxTagCount)\n      ? isItemHidden.size - maxTagCount\n      : Array.from(isItemHidden.values()).reduce((acc, isHidden) => (isHidden ? acc + 1 : acc), 0);\n\n    const withTagPlaceholder =\n      !isUndefined(maxTagCount) && mode === \"multiple\" && hiddenElementsCounter > 0;\n\n    if (label.length === 0) {\n      return null;\n    }\n\n    return (\n      <>\n        {label}\n        {withTagPlaceholder && renderTagPlaceholder(hiddenElementsCounter)}\n      </>\n    );\n  };\n\n  const renderSuffix = () => {\n    if (withDrawer) {\n      return (\n        <BarsOutlined\n          onClick={clickHandle}\n          css={[selectDefaultStyle.drawerIcon(theme), styles?.drawerIcon?.(theme)]}\n        />\n      );\n    }\n\n    if (showSearch && isSelectOpen) {\n      return <SearchOutlined />;\n    }\n\n    return suffixIcon;\n  };\n\n  const renderPlaceholder = () => (\n    <span css={[selectDefaultStyle.placeholder(theme), styles?.placeholder?.(theme)]}>\n      {placeholder}\n    </span>\n  );\n\n  const withClearButton = allowClear && !!filteredActiveValues.length;\n\n  const inputValue =\n    mode === \"multiple\" || isSelectOpen\n      ? (searchValue ?? searchInputValue)\n      : currentLabel[0]?.toString();\n\n  const isEmpty = filteredActiveValues.length === 0;\n  const singleModPlaceholder = currentLabel[0] ?? placeholder ?? \"\";\n  const multipleModPlaceholder = isEmpty ? placeholder : undefined;\n\n  const searchInputPlaceholder = mode === \"single\" ? singleModPlaceholder : multipleModPlaceholder;\n\n  const lettersNumber = (inputValue?.length ?? 0) + 1;\n\n  const hasIconPrefix = typeof prefix === \"object\";\n\n  const contextValue: BaseSelectContextShape<OptionValue> = {\n    currentValue: activeValues,\n    showOptionList: open ?? isSelectOpen,\n    setValue: changeHandle,\n    closeOptionList,\n    dropdownMinWidth,\n    dropdownMaxHeight,\n    dropdownPrompt,\n    loading,\n    dropdownClassName,\n    dropdownRender,\n    dropdownMatchSelectWidth,\n    referenceOffsetWidth,\n    floatingStyles,\n    setFloating: refs.setFloating,\n    floatingRef: refs.floating,\n    getPopupContainer,\n    virtual,\n    currentSelectingIndex,\n    emptyContent,\n    notFoundContent,\n    searchValue: searchValue ?? searchInputValue,\n    showSearch,\n    mode,\n    removeValue,\n    isItemHidden,\n    getCurrentSelectingValue,\n  };\n\n  return (\n    <baseSelectContext.Provider value={contextValue}>\n      <span\n        css={[selectDefaultStyle.wrapper(theme), styles?.wrapper?.(theme)]}\n        tabIndex={1}\n        onKeyDown={keyDownHandler}\n        onMouseOver={mouseOverHandle}\n        onMouseOut={mouseOutHandle}\n        onFocus={focusHandle}\n        onBlur={blurHandle}\n        autoFocus={autoFocus}\n        ref={controlRef}\n      >\n        <span\n          css={[selectDefaultStyle.body(theme), styles?.body?.(theme)]}\n          onClick={!withDrawer ? clickHandle : undefined}\n          ref={refs.setReference}\n        >\n          <span\n            css={[selectDefaultStyle.prefixAndContent(theme), styles?.prefixAndContent?.(theme)]}\n          >\n            {prefix && (\n              <span\n                css={[selectDefaultStyle.prefix(hasIconPrefix)(theme), styles?.prefix?.(theme)]}\n              >\n                {prefix}\n              </span>\n            )}\n\n            {showSearch ? (\n              <span ref={containerRef} css={selectDefaultStyle.content(theme)}>\n                {mode === \"multiple\" && renderLabel(filteredActiveValues, currentLabel)}\n                <input\n                  css={selectDefaultStyle.searchInput(theme)}\n                  value={inputValue ?? \"\"}\n                  onChange={searchHandle}\n                  placeholder={searchInputPlaceholder?.toString()}\n                  ref={inputRef}\n                  disabled={disabled}\n                  style={getSelectSearchInputWidthStyle(\n                    mode === \"multiple\",\n                    isEmpty,\n                    lettersNumber\n                  )}\n                  data-element=\"search-input\"\n                />\n              </span>\n            ) : (\n              <span\n                ref={containerRef}\n                css={[selectDefaultStyle.content(theme), styles?.content?.(theme)]}\n              >\n                {renderLabel(filteredActiveValues, currentLabel) ?? renderPlaceholder()}\n              </span>\n            )}\n          </span>\n\n          {withClearButton && (\n            <CloseCircleFilled\n              className=\"clean-button\"\n              onClick={clearSelect}\n              css={[selectDefaultStyle.cleanIcon(theme), styles?.cleanIcon?.(theme)]}\n              data-element=\"clean-button\"\n            />\n          )}\n          <span css={[selectDefaultStyle.suffixIcon(theme), styles?.suffixIcon?.(theme)]}>\n            {renderSuffix()}\n          </span>\n        </span>\n\n        <SelectOptionList<Option, OptionValue>\n          options={filteredAndSortedOptions}\n          renderDropdownItem={renderDropdownItem}\n          optionRender={optionRender}\n          virtualizerEstimateSize={virtualizerEstimateSize}\n          styles={styles?.dropdownStyle}\n        />\n      </span>\n    </baseSelectContext.Provider>\n  );\n};\n\nexport const BaseSelect = memo(BaseSelectComponent) as typeof BaseSelectComponent;\n"]} */"], children: placeholder });
+  };
+  const withClearButton = allowClear && !!filteredActiveValues.length;
+  const inputValue = mode === "multiple" || isSelectOpen ? searchValue ?? searchInputValue : (_b = currentLabel[0]) == null ? void 0 : _b.toString();
+  const isEmpty = filteredActiveValues.length === 0;
+  const singleModPlaceholder = currentLabel[0] ?? placeholder ?? "";
+  const multipleModPlaceholder = isEmpty ? placeholder : void 0;
+  const searchInputPlaceholder = mode === "single" ? singleModPlaceholder : multipleModPlaceholder;
+  const lettersNumber = ((inputValue == null ? void 0 : inputValue.length) ?? 0) + 1;
+  const hasIconPrefix = typeof prefix === "object";
+  const contextValue = {
+    currentValue: activeValues,
+    showOptionList: open ?? isSelectOpen,
+    setValue: changeHandle,
+    closeOptionList,
+    dropdownMinWidth,
+    dropdownMaxHeight,
+    dropdownPrompt,
+    loading,
+    dropdownClassName,
+    dropdownRender,
+    dropdownMatchSelectWidth,
+    referenceOffsetWidth,
+    floatingStyles,
+    setFloating: refs.setFloating,
+    floatingRef: refs.floating,
+    getPopupContainer,
+    virtual,
+    currentSelectingIndex,
+    emptyContent,
+    notFoundContent,
+    searchValue: searchValue ?? searchInputValue,
+    showSearch,
+    mode,
+    removeValue,
+    isItemHidden,
+    getCurrentSelectingValue
+  };
+  return /* @__PURE__ */ jsx(baseSelectContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxs("span", { css: [selectDefaultStyle.wrapper(theme), (_c = styles == null ? void 0 : styles.wrapper) == null ? void 0 : _c.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:BaseSelectComponent;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx"],"names":[],"mappings":"AA+cQ","file":"/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx","sourcesContent":["import {\n  type FocusEvent,\n  type KeyboardEvent,\n  memo,\n  type MouseEvent,\n  type PropsWithChildren,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport { getSelectDefaultStyle, getSelectSearchInputWidthStyle } from \"./BaseSelect.styles\";\nimport { useTheme } from \"hooks/useTheme\";\nimport { BarsOutlined, CloseCircleFilled, DownOutlined, SearchOutlined } from \"@infomaximum/icons\";\nimport { isFunction, isNull, isNumber, isUndefined } from \"lodash-es\";\nimport { autoUpdate, flip, offset, useFloating } from \"@floating-ui/react\";\nimport { convertSelectPlacement, getLabel, getVisibleLabels } from \"./BaseSelect.utils\";\nimport { useSearch } from \"./hooks/useSearch\";\nimport { useCurrentValue } from \"./hooks/useCurrentValue\";\nimport { SelectTag } from \"./components/SelectTag/SelectTag\";\nimport { useHideElements } from \"./hooks/useHideElements\";\nimport {\n  TagPlaceholder,\n  tagPlaceholderDataElement,\n} from \"./components/TagPlaceholder/TagPlaceholder\";\nimport type { BaseSelectOptionInterface, BaseSelectProps } from \"./BaseSelect.types\";\nimport { SelectOptionList } from \"./components/SelectOptionList/SelectOptionList\";\nimport { createBaseSelectContext, type BaseSelectContextShape } from \"./contexts/BaseSelectContext\";\n\nconst BaseSelectComponent = <Option extends BaseSelectOptionInterface<OptionValue>, OptionValue>({\n  options = [],\n  mode = \"single\",\n  variant = \"outlined\",\n  defaultValue,\n  defaultOpen = false,\n  defaultActiveFirstOption,\n  value,\n  open,\n  placeholder,\n  dropdownMinWidth = 120,\n  dropdownMaxHeight = 414,\n  allowClear = false,\n  autoFocus,\n  prefix,\n  suffixIcon = <DownOutlined />,\n  status = \"default\",\n  disabled = false,\n  dropdownPrompt,\n  loading = false,\n  dropdownClassName,\n  styles,\n  dropdownMatchSelectWidth = true,\n  placement = \"bottomLeft\",\n  virtual = true,\n  emptyContent = \"\",\n  showSearch = mode === \"single\" ? false : true,\n  searchValue,\n  notFoundContent = \"Not found\",\n  optionLabelProp = \"title\",\n  drawer = false,\n  autoClearSearchValue = true,\n  maxTagCount,\n  maxTagTextLength,\n  maxTagPlaceholder,\n  currentSelectingIndex,\n  getCurrentSelectingValue,\n  onKeyControl,\n  getOptionByValue,\n  virtualizerEstimateSize,\n  filterOptions,\n  filterSort,\n  valuesFilter,\n  dropdownRender,\n  optionRender,\n  labelRender,\n  onBlur,\n  onChange,\n  onClear,\n  onDropdownVisibleChange,\n  onFocus,\n  onInputKeyDown,\n  onSelect,\n  getPopupContainer = () => document.body,\n  onSearch,\n  tagRender,\n  onDeselect,\n  renderDropdownItem,\n  onTagClose,\n}: PropsWithChildren<BaseSelectProps<Option, OptionValue>>) => {\n  const theme = useTheme();\n  const baseSelectContext = createBaseSelectContext<OptionValue>();\n\n  const { filteredAndSortedOptions, searchInputValue, searchHandle, clearSearchValue } = useSearch<\n    Option,\n    OptionValue\n  >({\n    options,\n    searchValue,\n    onSearch,\n    filterSort,\n    filterOptions,\n  });\n\n  const { currentValue, changeCurrentValue, removeValue, clearCurrentValue } = useCurrentValue(\n    mode,\n    defaultValue,\n    defaultActiveFirstOption,\n    options,\n    onDeselect\n  );\n\n  const [isSelectOpen, setIsSelectOpen] = useState(defaultOpen);\n  const [isHover, setIsHover] = useState(false);\n\n  const isInitialMount = useRef(true);\n  const controlRef = useRef<HTMLSpanElement | null>(null);\n  const inputRef = useRef<HTMLInputElement | null>(null);\n\n  const referenceOffsetWidth = controlRef.current?.offsetWidth;\n\n  const { refs, floatingStyles } = useFloating<HTMLSpanElement>({\n    whileElementsMounted: autoUpdate,\n    placement: convertSelectPlacement(placement),\n    middleware: [offset(4), flip()],\n  });\n\n  const returnFocusToWrapper = useCallback(() => {\n    setTimeout(() => {\n      controlRef.current?.focus();\n    });\n  }, []);\n\n  const returnFocusToInput = useCallback(() => {\n    setTimeout(() => {\n      inputRef.current?.focus();\n    });\n  }, []);\n\n  useEffect(() => {\n    if (!isInitialMount.current) {\n      const options = currentValue.reduce((acc: Option[], value) => {\n        const option = getOptionByValue(value);\n\n        if (isUndefined(option)) {\n          return acc;\n        }\n\n        return [...acc, option];\n      }, []);\n\n      onChange?.(currentValue, options);\n    }\n  }, [currentValue, getOptionByValue, onChange]);\n\n  useEffect(() => {\n    if (isInitialMount.current) {\n      isInitialMount.current = false;\n    } else {\n      onDropdownVisibleChange?.();\n    }\n  }, [isSelectOpen, onDropdownVisibleChange]);\n\n  const activeValues = useMemo(() => {\n    return Array.isArray(value) ? value : isUndefined(value) ? currentValue : [value];\n  }, [currentValue, value]);\n\n  const selectDefaultStyle = getSelectDefaultStyle({\n    status,\n    disabled,\n    variant,\n    multiple: mode === \"multiple\",\n    isHover,\n    maxTagCount,\n    withPrefix: !!prefix,\n    isEmpty: activeValues.length === 0,\n  });\n\n  const filteredActiveValues = useMemo(() => {\n    return isFunction(valuesFilter) ? valuesFilter(activeValues) : activeValues;\n  }, [activeValues, valuesFilter]);\n\n  const { containerRef, isItemHidden } = useHideElements(\n    filteredActiveValues,\n    theme.spaceXS,\n    inputRef,\n    maxTagCount\n  );\n\n  const currentLabel = getLabel<Option, OptionValue>(\n    filteredActiveValues,\n    getOptionByValue,\n    optionLabelProp\n  );\n\n  const withDrawer = mode === \"multiple\" && drawer;\n  const withAutoClear = mode === \"single\" || autoClearSearchValue;\n\n  const clickHandle = () => {\n    if (disabled) {\n      return;\n    }\n\n    setIsSelectOpen((prev) => !prev);\n  };\n\n  const changeHandle = useCallback(\n    (value: OptionValue | OptionValue[]) => {\n      changeCurrentValue(value);\n\n      if (Array.isArray(value)) {\n        return;\n      }\n\n      const option = getOptionByValue(value);\n\n      if (withAutoClear) {\n        clearSearchValue();\n      }\n\n      if (option) {\n        onSelect?.(value, option);\n      }\n    },\n    [changeCurrentValue, clearSearchValue, getOptionByValue, onSelect, withAutoClear]\n  );\n\n  const closeOptionList = useCallback(() => {\n    setIsSelectOpen(false);\n  }, []);\n\n  const blurHandle = (e: FocusEvent) => {\n    const isFocusOnOptionList = refs.floating.current?.contains(e.relatedTarget);\n    const isFocusOnSearchInput = !isNull(inputRef.current) && e.relatedTarget === inputRef.current;\n    const isFocusOnControl = e.relatedTarget === controlRef.current;\n\n    if (isFocusOnOptionList || isFocusOnSearchInput || isFocusOnControl) {\n      if (showSearch) {\n        returnFocusToInput();\n      } else {\n        returnFocusToWrapper();\n      }\n\n      return;\n    }\n\n    onBlur?.(e);\n    clearSearchValue();\n    closeOptionList();\n  };\n\n  const clearSelect = useCallback(\n    (e: MouseEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n\n      clearCurrentValue();\n      onClear?.();\n    },\n    [clearCurrentValue, onClear]\n  );\n\n  const keyDownHandler = (e: KeyboardEvent) => {\n    if (e.key === \"Enter\") {\n      if (isSelectOpen) {\n        const value = getCurrentSelectingValue();\n\n        if (!value) {\n          return;\n        }\n\n        if (currentValue.includes(value)) {\n          removeValue(value);\n        } else {\n          changeCurrentValue(value);\n        }\n\n        if (withAutoClear) {\n          clearSearchValue();\n        }\n      }\n\n      clickHandle();\n    }\n\n    setIsSelectOpen(true);\n\n    onKeyControl(e);\n    onInputKeyDown?.(e);\n  };\n\n  const mouseOverHandle = () => {\n    setIsHover(true);\n  };\n\n  const mouseOutHandle = () => {\n    setIsHover(false);\n  };\n\n  const focusHandle = (e: FocusEvent) => {\n    onFocus?.(e);\n\n    if (!showSearch) {\n      return;\n    }\n\n    returnFocusToInput();\n  };\n\n  const renderTagPlaceholder = (hiddenElementsCounter: number) => {\n    if (isUndefined(maxTagPlaceholder)) {\n      return <TagPlaceholder hiddenElementsCounter={hiddenElementsCounter} />;\n    }\n\n    if (!isFunction(maxTagPlaceholder)) {\n      return <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder}</span>;\n    }\n\n    const hiddenElements = currentValue.reduce((acc: Option[], value) => {\n      const isHidden = isItemHidden.get(value);\n      const option = getOptionByValue(value);\n\n      if (!isHidden || isUndefined(option)) {\n        return acc;\n      }\n\n      acc.push(option);\n\n      return acc;\n    }, []);\n\n    return (\n      <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder(hiddenElements)}</span>\n    );\n  };\n\n  const renderLabel = (values: OptionValue[], currentLabel: string[]) => {\n    const visibleLabels = getVisibleLabels(currentLabel, maxTagCount);\n\n    const label = visibleLabels.map((label, index) => {\n      const value = values[index] as OptionValue;\n\n      if (isFunction(labelRender)) {\n        return labelRender({ label, value });\n      }\n\n      if (mode === \"single\") {\n        return label;\n      }\n\n      if (isFunction(tagRender)) {\n        return tagRender(label);\n      }\n\n      const isHidden = !!isItemHidden.get(value);\n\n      return (\n        <SelectTag<OptionValue>\n          value={value}\n          label={label}\n          removeValue={removeValue}\n          maxTagTextLength={maxTagTextLength}\n          isBorderless={variant === \"borderless\"}\n          isError={status === \"error\"}\n          disabled={disabled}\n          isHidden={isHidden}\n          onTagClose={onTagClose}\n          key={value?.toString()}\n        />\n      );\n    });\n\n    const hiddenElementsCounter = isNumber(maxTagCount)\n      ? isItemHidden.size - maxTagCount\n      : Array.from(isItemHidden.values()).reduce((acc, isHidden) => (isHidden ? acc + 1 : acc), 0);\n\n    const withTagPlaceholder =\n      !isUndefined(maxTagCount) && mode === \"multiple\" && hiddenElementsCounter > 0;\n\n    if (label.length === 0) {\n      return null;\n    }\n\n    return (\n      <>\n        {label}\n        {withTagPlaceholder && renderTagPlaceholder(hiddenElementsCounter)}\n      </>\n    );\n  };\n\n  const renderSuffix = () => {\n    if (withDrawer) {\n      return (\n        <BarsOutlined\n          onClick={clickHandle}\n          css={[selectDefaultStyle.drawerIcon(theme), styles?.drawerIcon?.(theme)]}\n        />\n      );\n    }\n\n    if (showSearch && isSelectOpen) {\n      return <SearchOutlined />;\n    }\n\n    return suffixIcon;\n  };\n\n  const renderPlaceholder = () => (\n    <span css={[selectDefaultStyle.placeholder(theme), styles?.placeholder?.(theme)]}>\n      {placeholder}\n    </span>\n  );\n\n  const withClearButton = allowClear && !!filteredActiveValues.length;\n\n  const inputValue =\n    mode === \"multiple\" || isSelectOpen\n      ? (searchValue ?? searchInputValue)\n      : currentLabel[0]?.toString();\n\n  const isEmpty = filteredActiveValues.length === 0;\n  const singleModPlaceholder = currentLabel[0] ?? placeholder ?? \"\";\n  const multipleModPlaceholder = isEmpty ? placeholder : undefined;\n\n  const searchInputPlaceholder = mode === \"single\" ? singleModPlaceholder : multipleModPlaceholder;\n\n  const lettersNumber = (inputValue?.length ?? 0) + 1;\n\n  const hasIconPrefix = typeof prefix === \"object\";\n\n  const contextValue: BaseSelectContextShape<OptionValue> = {\n    currentValue: activeValues,\n    showOptionList: open ?? isSelectOpen,\n    setValue: changeHandle,\n    closeOptionList,\n    dropdownMinWidth,\n    dropdownMaxHeight,\n    dropdownPrompt,\n    loading,\n    dropdownClassName,\n    dropdownRender,\n    dropdownMatchSelectWidth,\n    referenceOffsetWidth,\n    floatingStyles,\n    setFloating: refs.setFloating,\n    floatingRef: refs.floating,\n    getPopupContainer,\n    virtual,\n    currentSelectingIndex,\n    emptyContent,\n    notFoundContent,\n    searchValue: searchValue ?? searchInputValue,\n    showSearch,\n    mode,\n    removeValue,\n    isItemHidden,\n    getCurrentSelectingValue,\n  };\n\n  return (\n    <baseSelectContext.Provider value={contextValue}>\n      <span\n        css={[selectDefaultStyle.wrapper(theme), styles?.wrapper?.(theme)]}\n        tabIndex={1}\n        onKeyDown={keyDownHandler}\n        onMouseOver={mouseOverHandle}\n        onMouseOut={mouseOutHandle}\n        onFocus={focusHandle}\n        onBlur={blurHandle}\n        autoFocus={autoFocus}\n        ref={controlRef}\n      >\n        <span\n          css={[selectDefaultStyle.body(theme), styles?.body?.(theme)]}\n          onClick={!withDrawer ? clickHandle : undefined}\n          ref={refs.setReference}\n        >\n          <span\n            css={[selectDefaultStyle.prefixAndContent(theme), styles?.prefixAndContent?.(theme)]}\n          >\n            {prefix && (\n              <span\n                css={[selectDefaultStyle.prefix(hasIconPrefix)(theme), styles?.prefix?.(theme)]}\n              >\n                {prefix}\n              </span>\n            )}\n\n            {showSearch ? (\n              <span ref={containerRef} css={selectDefaultStyle.content(theme)}>\n                {mode === \"multiple\" && renderLabel(filteredActiveValues, currentLabel)}\n                <input\n                  css={selectDefaultStyle.searchInput(theme)}\n                  value={inputValue ?? \"\"}\n                  onChange={searchHandle}\n                  placeholder={searchInputPlaceholder?.toString()}\n                  ref={inputRef}\n                  disabled={disabled}\n                  style={getSelectSearchInputWidthStyle(\n                    mode === \"multiple\",\n                    isEmpty,\n                    lettersNumber\n                  )}\n                  data-element=\"search-input\"\n                />\n              </span>\n            ) : (\n              <span\n                ref={containerRef}\n                css={[selectDefaultStyle.content(theme), styles?.content?.(theme)]}\n              >\n                {renderLabel(filteredActiveValues, currentLabel) ?? renderPlaceholder()}\n              </span>\n            )}\n          </span>\n\n          {withClearButton && (\n            <CloseCircleFilled\n              className=\"clean-button\"\n              onClick={clearSelect}\n              css={[selectDefaultStyle.cleanIcon(theme), styles?.cleanIcon?.(theme)]}\n              data-element=\"clean-button\"\n            />\n          )}\n          <span css={[selectDefaultStyle.suffixIcon(theme), styles?.suffixIcon?.(theme)]}>\n            {renderSuffix()}\n          </span>\n        </span>\n\n        <SelectOptionList<Option, OptionValue>\n          options={filteredAndSortedOptions}\n          renderDropdownItem={renderDropdownItem}\n          optionRender={optionRender}\n          virtualizerEstimateSize={virtualizerEstimateSize}\n          styles={styles?.dropdownStyle}\n        />\n      </span>\n    </baseSelectContext.Provider>\n  );\n};\n\nexport const BaseSelect = memo(BaseSelectComponent) as typeof BaseSelectComponent;\n"]} */"], tabIndex: 1, onKeyDown: keyDownHandler, onMouseOver: mouseOverHandle, onMouseOut: mouseOutHandle, onFocus: focusHandle, onBlur: blurHandle, autoFocus, ref: controlRef, children: [
+    /* @__PURE__ */ jsxs("span", { css: [selectDefaultStyle.body(theme), (_d = styles == null ? void 0 : styles.body) == null ? void 0 : _d.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:BaseSelectComponent;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx"],"names":[],"mappings":"AA0dU","file":"/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx","sourcesContent":["import {\n  type FocusEvent,\n  type KeyboardEvent,\n  memo,\n  type MouseEvent,\n  type PropsWithChildren,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport { getSelectDefaultStyle, getSelectSearchInputWidthStyle } from \"./BaseSelect.styles\";\nimport { useTheme } from \"hooks/useTheme\";\nimport { BarsOutlined, CloseCircleFilled, DownOutlined, SearchOutlined } from \"@infomaximum/icons\";\nimport { isFunction, isNull, isNumber, isUndefined } from \"lodash-es\";\nimport { autoUpdate, flip, offset, useFloating } from \"@floating-ui/react\";\nimport { convertSelectPlacement, getLabel, getVisibleLabels } from \"./BaseSelect.utils\";\nimport { useSearch } from \"./hooks/useSearch\";\nimport { useCurrentValue } from \"./hooks/useCurrentValue\";\nimport { SelectTag } from \"./components/SelectTag/SelectTag\";\nimport { useHideElements } from \"./hooks/useHideElements\";\nimport {\n  TagPlaceholder,\n  tagPlaceholderDataElement,\n} from \"./components/TagPlaceholder/TagPlaceholder\";\nimport type { BaseSelectOptionInterface, BaseSelectProps } from \"./BaseSelect.types\";\nimport { SelectOptionList } from \"./components/SelectOptionList/SelectOptionList\";\nimport { createBaseSelectContext, type BaseSelectContextShape } from \"./contexts/BaseSelectContext\";\n\nconst BaseSelectComponent = <Option extends BaseSelectOptionInterface<OptionValue>, OptionValue>({\n  options = [],\n  mode = \"single\",\n  variant = \"outlined\",\n  defaultValue,\n  defaultOpen = false,\n  defaultActiveFirstOption,\n  value,\n  open,\n  placeholder,\n  dropdownMinWidth = 120,\n  dropdownMaxHeight = 414,\n  allowClear = false,\n  autoFocus,\n  prefix,\n  suffixIcon = <DownOutlined />,\n  status = \"default\",\n  disabled = false,\n  dropdownPrompt,\n  loading = false,\n  dropdownClassName,\n  styles,\n  dropdownMatchSelectWidth = true,\n  placement = \"bottomLeft\",\n  virtual = true,\n  emptyContent = \"\",\n  showSearch = mode === \"single\" ? false : true,\n  searchValue,\n  notFoundContent = \"Not found\",\n  optionLabelProp = \"title\",\n  drawer = false,\n  autoClearSearchValue = true,\n  maxTagCount,\n  maxTagTextLength,\n  maxTagPlaceholder,\n  currentSelectingIndex,\n  getCurrentSelectingValue,\n  onKeyControl,\n  getOptionByValue,\n  virtualizerEstimateSize,\n  filterOptions,\n  filterSort,\n  valuesFilter,\n  dropdownRender,\n  optionRender,\n  labelRender,\n  onBlur,\n  onChange,\n  onClear,\n  onDropdownVisibleChange,\n  onFocus,\n  onInputKeyDown,\n  onSelect,\n  getPopupContainer = () => document.body,\n  onSearch,\n  tagRender,\n  onDeselect,\n  renderDropdownItem,\n  onTagClose,\n}: PropsWithChildren<BaseSelectProps<Option, OptionValue>>) => {\n  const theme = useTheme();\n  const baseSelectContext = createBaseSelectContext<OptionValue>();\n\n  const { filteredAndSortedOptions, searchInputValue, searchHandle, clearSearchValue } = useSearch<\n    Option,\n    OptionValue\n  >({\n    options,\n    searchValue,\n    onSearch,\n    filterSort,\n    filterOptions,\n  });\n\n  const { currentValue, changeCurrentValue, removeValue, clearCurrentValue } = useCurrentValue(\n    mode,\n    defaultValue,\n    defaultActiveFirstOption,\n    options,\n    onDeselect\n  );\n\n  const [isSelectOpen, setIsSelectOpen] = useState(defaultOpen);\n  const [isHover, setIsHover] = useState(false);\n\n  const isInitialMount = useRef(true);\n  const controlRef = useRef<HTMLSpanElement | null>(null);\n  const inputRef = useRef<HTMLInputElement | null>(null);\n\n  const referenceOffsetWidth = controlRef.current?.offsetWidth;\n\n  const { refs, floatingStyles } = useFloating<HTMLSpanElement>({\n    whileElementsMounted: autoUpdate,\n    placement: convertSelectPlacement(placement),\n    middleware: [offset(4), flip()],\n  });\n\n  const returnFocusToWrapper = useCallback(() => {\n    setTimeout(() => {\n      controlRef.current?.focus();\n    });\n  }, []);\n\n  const returnFocusToInput = useCallback(() => {\n    setTimeout(() => {\n      inputRef.current?.focus();\n    });\n  }, []);\n\n  useEffect(() => {\n    if (!isInitialMount.current) {\n      const options = currentValue.reduce((acc: Option[], value) => {\n        const option = getOptionByValue(value);\n\n        if (isUndefined(option)) {\n          return acc;\n        }\n\n        return [...acc, option];\n      }, []);\n\n      onChange?.(currentValue, options);\n    }\n  }, [currentValue, getOptionByValue, onChange]);\n\n  useEffect(() => {\n    if (isInitialMount.current) {\n      isInitialMount.current = false;\n    } else {\n      onDropdownVisibleChange?.();\n    }\n  }, [isSelectOpen, onDropdownVisibleChange]);\n\n  const activeValues = useMemo(() => {\n    return Array.isArray(value) ? value : isUndefined(value) ? currentValue : [value];\n  }, [currentValue, value]);\n\n  const selectDefaultStyle = getSelectDefaultStyle({\n    status,\n    disabled,\n    variant,\n    multiple: mode === \"multiple\",\n    isHover,\n    maxTagCount,\n    withPrefix: !!prefix,\n    isEmpty: activeValues.length === 0,\n  });\n\n  const filteredActiveValues = useMemo(() => {\n    return isFunction(valuesFilter) ? valuesFilter(activeValues) : activeValues;\n  }, [activeValues, valuesFilter]);\n\n  const { containerRef, isItemHidden } = useHideElements(\n    filteredActiveValues,\n    theme.spaceXS,\n    inputRef,\n    maxTagCount\n  );\n\n  const currentLabel = getLabel<Option, OptionValue>(\n    filteredActiveValues,\n    getOptionByValue,\n    optionLabelProp\n  );\n\n  const withDrawer = mode === \"multiple\" && drawer;\n  const withAutoClear = mode === \"single\" || autoClearSearchValue;\n\n  const clickHandle = () => {\n    if (disabled) {\n      return;\n    }\n\n    setIsSelectOpen((prev) => !prev);\n  };\n\n  const changeHandle = useCallback(\n    (value: OptionValue | OptionValue[]) => {\n      changeCurrentValue(value);\n\n      if (Array.isArray(value)) {\n        return;\n      }\n\n      const option = getOptionByValue(value);\n\n      if (withAutoClear) {\n        clearSearchValue();\n      }\n\n      if (option) {\n        onSelect?.(value, option);\n      }\n    },\n    [changeCurrentValue, clearSearchValue, getOptionByValue, onSelect, withAutoClear]\n  );\n\n  const closeOptionList = useCallback(() => {\n    setIsSelectOpen(false);\n  }, []);\n\n  const blurHandle = (e: FocusEvent) => {\n    const isFocusOnOptionList = refs.floating.current?.contains(e.relatedTarget);\n    const isFocusOnSearchInput = !isNull(inputRef.current) && e.relatedTarget === inputRef.current;\n    const isFocusOnControl = e.relatedTarget === controlRef.current;\n\n    if (isFocusOnOptionList || isFocusOnSearchInput || isFocusOnControl) {\n      if (showSearch) {\n        returnFocusToInput();\n      } else {\n        returnFocusToWrapper();\n      }\n\n      return;\n    }\n\n    onBlur?.(e);\n    clearSearchValue();\n    closeOptionList();\n  };\n\n  const clearSelect = useCallback(\n    (e: MouseEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n\n      clearCurrentValue();\n      onClear?.();\n    },\n    [clearCurrentValue, onClear]\n  );\n\n  const keyDownHandler = (e: KeyboardEvent) => {\n    if (e.key === \"Enter\") {\n      if (isSelectOpen) {\n        const value = getCurrentSelectingValue();\n\n        if (!value) {\n          return;\n        }\n\n        if (currentValue.includes(value)) {\n          removeValue(value);\n        } else {\n          changeCurrentValue(value);\n        }\n\n        if (withAutoClear) {\n          clearSearchValue();\n        }\n      }\n\n      clickHandle();\n    }\n\n    setIsSelectOpen(true);\n\n    onKeyControl(e);\n    onInputKeyDown?.(e);\n  };\n\n  const mouseOverHandle = () => {\n    setIsHover(true);\n  };\n\n  const mouseOutHandle = () => {\n    setIsHover(false);\n  };\n\n  const focusHandle = (e: FocusEvent) => {\n    onFocus?.(e);\n\n    if (!showSearch) {\n      return;\n    }\n\n    returnFocusToInput();\n  };\n\n  const renderTagPlaceholder = (hiddenElementsCounter: number) => {\n    if (isUndefined(maxTagPlaceholder)) {\n      return <TagPlaceholder hiddenElementsCounter={hiddenElementsCounter} />;\n    }\n\n    if (!isFunction(maxTagPlaceholder)) {\n      return <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder}</span>;\n    }\n\n    const hiddenElements = currentValue.reduce((acc: Option[], value) => {\n      const isHidden = isItemHidden.get(value);\n      const option = getOptionByValue(value);\n\n      if (!isHidden || isUndefined(option)) {\n        return acc;\n      }\n\n      acc.push(option);\n\n      return acc;\n    }, []);\n\n    return (\n      <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder(hiddenElements)}</span>\n    );\n  };\n\n  const renderLabel = (values: OptionValue[], currentLabel: string[]) => {\n    const visibleLabels = getVisibleLabels(currentLabel, maxTagCount);\n\n    const label = visibleLabels.map((label, index) => {\n      const value = values[index] as OptionValue;\n\n      if (isFunction(labelRender)) {\n        return labelRender({ label, value });\n      }\n\n      if (mode === \"single\") {\n        return label;\n      }\n\n      if (isFunction(tagRender)) {\n        return tagRender(label);\n      }\n\n      const isHidden = !!isItemHidden.get(value);\n\n      return (\n        <SelectTag<OptionValue>\n          value={value}\n          label={label}\n          removeValue={removeValue}\n          maxTagTextLength={maxTagTextLength}\n          isBorderless={variant === \"borderless\"}\n          isError={status === \"error\"}\n          disabled={disabled}\n          isHidden={isHidden}\n          onTagClose={onTagClose}\n          key={value?.toString()}\n        />\n      );\n    });\n\n    const hiddenElementsCounter = isNumber(maxTagCount)\n      ? isItemHidden.size - maxTagCount\n      : Array.from(isItemHidden.values()).reduce((acc, isHidden) => (isHidden ? acc + 1 : acc), 0);\n\n    const withTagPlaceholder =\n      !isUndefined(maxTagCount) && mode === \"multiple\" && hiddenElementsCounter > 0;\n\n    if (label.length === 0) {\n      return null;\n    }\n\n    return (\n      <>\n        {label}\n        {withTagPlaceholder && renderTagPlaceholder(hiddenElementsCounter)}\n      </>\n    );\n  };\n\n  const renderSuffix = () => {\n    if (withDrawer) {\n      return (\n        <BarsOutlined\n          onClick={clickHandle}\n          css={[selectDefaultStyle.drawerIcon(theme), styles?.drawerIcon?.(theme)]}\n        />\n      );\n    }\n\n    if (showSearch && isSelectOpen) {\n      return <SearchOutlined />;\n    }\n\n    return suffixIcon;\n  };\n\n  const renderPlaceholder = () => (\n    <span css={[selectDefaultStyle.placeholder(theme), styles?.placeholder?.(theme)]}>\n      {placeholder}\n    </span>\n  );\n\n  const withClearButton = allowClear && !!filteredActiveValues.length;\n\n  const inputValue =\n    mode === \"multiple\" || isSelectOpen\n      ? (searchValue ?? searchInputValue)\n      : currentLabel[0]?.toString();\n\n  const isEmpty = filteredActiveValues.length === 0;\n  const singleModPlaceholder = currentLabel[0] ?? placeholder ?? \"\";\n  const multipleModPlaceholder = isEmpty ? placeholder : undefined;\n\n  const searchInputPlaceholder = mode === \"single\" ? singleModPlaceholder : multipleModPlaceholder;\n\n  const lettersNumber = (inputValue?.length ?? 0) + 1;\n\n  const hasIconPrefix = typeof prefix === \"object\";\n\n  const contextValue: BaseSelectContextShape<OptionValue> = {\n    currentValue: activeValues,\n    showOptionList: open ?? isSelectOpen,\n    setValue: changeHandle,\n    closeOptionList,\n    dropdownMinWidth,\n    dropdownMaxHeight,\n    dropdownPrompt,\n    loading,\n    dropdownClassName,\n    dropdownRender,\n    dropdownMatchSelectWidth,\n    referenceOffsetWidth,\n    floatingStyles,\n    setFloating: refs.setFloating,\n    floatingRef: refs.floating,\n    getPopupContainer,\n    virtual,\n    currentSelectingIndex,\n    emptyContent,\n    notFoundContent,\n    searchValue: searchValue ?? searchInputValue,\n    showSearch,\n    mode,\n    removeValue,\n    isItemHidden,\n    getCurrentSelectingValue,\n  };\n\n  return (\n    <baseSelectContext.Provider value={contextValue}>\n      <span\n        css={[selectDefaultStyle.wrapper(theme), styles?.wrapper?.(theme)]}\n        tabIndex={1}\n        onKeyDown={keyDownHandler}\n        onMouseOver={mouseOverHandle}\n        onMouseOut={mouseOutHandle}\n        onFocus={focusHandle}\n        onBlur={blurHandle}\n        autoFocus={autoFocus}\n        ref={controlRef}\n      >\n        <span\n          css={[selectDefaultStyle.body(theme), styles?.body?.(theme)]}\n          onClick={!withDrawer ? clickHandle : undefined}\n          ref={refs.setReference}\n        >\n          <span\n            css={[selectDefaultStyle.prefixAndContent(theme), styles?.prefixAndContent?.(theme)]}\n          >\n            {prefix && (\n              <span\n                css={[selectDefaultStyle.prefix(hasIconPrefix)(theme), styles?.prefix?.(theme)]}\n              >\n                {prefix}\n              </span>\n            )}\n\n            {showSearch ? (\n              <span ref={containerRef} css={selectDefaultStyle.content(theme)}>\n                {mode === \"multiple\" && renderLabel(filteredActiveValues, currentLabel)}\n                <input\n                  css={selectDefaultStyle.searchInput(theme)}\n                  value={inputValue ?? \"\"}\n                  onChange={searchHandle}\n                  placeholder={searchInputPlaceholder?.toString()}\n                  ref={inputRef}\n                  disabled={disabled}\n                  style={getSelectSearchInputWidthStyle(\n                    mode === \"multiple\",\n                    isEmpty,\n                    lettersNumber\n                  )}\n                  data-element=\"search-input\"\n                />\n              </span>\n            ) : (\n              <span\n                ref={containerRef}\n                css={[selectDefaultStyle.content(theme), styles?.content?.(theme)]}\n              >\n                {renderLabel(filteredActiveValues, currentLabel) ?? renderPlaceholder()}\n              </span>\n            )}\n          </span>\n\n          {withClearButton && (\n            <CloseCircleFilled\n              className=\"clean-button\"\n              onClick={clearSelect}\n              css={[selectDefaultStyle.cleanIcon(theme), styles?.cleanIcon?.(theme)]}\n              data-element=\"clean-button\"\n            />\n          )}\n          <span css={[selectDefaultStyle.suffixIcon(theme), styles?.suffixIcon?.(theme)]}>\n            {renderSuffix()}\n          </span>\n        </span>\n\n        <SelectOptionList<Option, OptionValue>\n          options={filteredAndSortedOptions}\n          renderDropdownItem={renderDropdownItem}\n          optionRender={optionRender}\n          virtualizerEstimateSize={virtualizerEstimateSize}\n          styles={styles?.dropdownStyle}\n        />\n      </span>\n    </baseSelectContext.Provider>\n  );\n};\n\nexport const BaseSelect = memo(BaseSelectComponent) as typeof BaseSelectComponent;\n"]} */"], onClick: !withDrawer ? clickHandle : void 0, ref: refs.setReference, children: [
+      /* @__PURE__ */ jsxs("span", { css: [selectDefaultStyle.prefixAndContent(theme), (_e = styles == null ? void 0 : styles.prefixAndContent) == null ? void 0 : _e.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:BaseSelectComponent;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx"],"names":[],"mappings":"AA+dY","file":"/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx","sourcesContent":["import {\n  type FocusEvent,\n  type KeyboardEvent,\n  memo,\n  type MouseEvent,\n  type PropsWithChildren,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport { getSelectDefaultStyle, getSelectSearchInputWidthStyle } from \"./BaseSelect.styles\";\nimport { useTheme } from \"hooks/useTheme\";\nimport { BarsOutlined, CloseCircleFilled, DownOutlined, SearchOutlined } from \"@infomaximum/icons\";\nimport { isFunction, isNull, isNumber, isUndefined } from \"lodash-es\";\nimport { autoUpdate, flip, offset, useFloating } from \"@floating-ui/react\";\nimport { convertSelectPlacement, getLabel, getVisibleLabels } from \"./BaseSelect.utils\";\nimport { useSearch } from \"./hooks/useSearch\";\nimport { useCurrentValue } from \"./hooks/useCurrentValue\";\nimport { SelectTag } from \"./components/SelectTag/SelectTag\";\nimport { useHideElements } from \"./hooks/useHideElements\";\nimport {\n  TagPlaceholder,\n  tagPlaceholderDataElement,\n} from \"./components/TagPlaceholder/TagPlaceholder\";\nimport type { BaseSelectOptionInterface, BaseSelectProps } from \"./BaseSelect.types\";\nimport { SelectOptionList } from \"./components/SelectOptionList/SelectOptionList\";\nimport { createBaseSelectContext, type BaseSelectContextShape } from \"./contexts/BaseSelectContext\";\n\nconst BaseSelectComponent = <Option extends BaseSelectOptionInterface<OptionValue>, OptionValue>({\n  options = [],\n  mode = \"single\",\n  variant = \"outlined\",\n  defaultValue,\n  defaultOpen = false,\n  defaultActiveFirstOption,\n  value,\n  open,\n  placeholder,\n  dropdownMinWidth = 120,\n  dropdownMaxHeight = 414,\n  allowClear = false,\n  autoFocus,\n  prefix,\n  suffixIcon = <DownOutlined />,\n  status = \"default\",\n  disabled = false,\n  dropdownPrompt,\n  loading = false,\n  dropdownClassName,\n  styles,\n  dropdownMatchSelectWidth = true,\n  placement = \"bottomLeft\",\n  virtual = true,\n  emptyContent = \"\",\n  showSearch = mode === \"single\" ? false : true,\n  searchValue,\n  notFoundContent = \"Not found\",\n  optionLabelProp = \"title\",\n  drawer = false,\n  autoClearSearchValue = true,\n  maxTagCount,\n  maxTagTextLength,\n  maxTagPlaceholder,\n  currentSelectingIndex,\n  getCurrentSelectingValue,\n  onKeyControl,\n  getOptionByValue,\n  virtualizerEstimateSize,\n  filterOptions,\n  filterSort,\n  valuesFilter,\n  dropdownRender,\n  optionRender,\n  labelRender,\n  onBlur,\n  onChange,\n  onClear,\n  onDropdownVisibleChange,\n  onFocus,\n  onInputKeyDown,\n  onSelect,\n  getPopupContainer = () => document.body,\n  onSearch,\n  tagRender,\n  onDeselect,\n  renderDropdownItem,\n  onTagClose,\n}: PropsWithChildren<BaseSelectProps<Option, OptionValue>>) => {\n  const theme = useTheme();\n  const baseSelectContext = createBaseSelectContext<OptionValue>();\n\n  const { filteredAndSortedOptions, searchInputValue, searchHandle, clearSearchValue } = useSearch<\n    Option,\n    OptionValue\n  >({\n    options,\n    searchValue,\n    onSearch,\n    filterSort,\n    filterOptions,\n  });\n\n  const { currentValue, changeCurrentValue, removeValue, clearCurrentValue } = useCurrentValue(\n    mode,\n    defaultValue,\n    defaultActiveFirstOption,\n    options,\n    onDeselect\n  );\n\n  const [isSelectOpen, setIsSelectOpen] = useState(defaultOpen);\n  const [isHover, setIsHover] = useState(false);\n\n  const isInitialMount = useRef(true);\n  const controlRef = useRef<HTMLSpanElement | null>(null);\n  const inputRef = useRef<HTMLInputElement | null>(null);\n\n  const referenceOffsetWidth = controlRef.current?.offsetWidth;\n\n  const { refs, floatingStyles } = useFloating<HTMLSpanElement>({\n    whileElementsMounted: autoUpdate,\n    placement: convertSelectPlacement(placement),\n    middleware: [offset(4), flip()],\n  });\n\n  const returnFocusToWrapper = useCallback(() => {\n    setTimeout(() => {\n      controlRef.current?.focus();\n    });\n  }, []);\n\n  const returnFocusToInput = useCallback(() => {\n    setTimeout(() => {\n      inputRef.current?.focus();\n    });\n  }, []);\n\n  useEffect(() => {\n    if (!isInitialMount.current) {\n      const options = currentValue.reduce((acc: Option[], value) => {\n        const option = getOptionByValue(value);\n\n        if (isUndefined(option)) {\n          return acc;\n        }\n\n        return [...acc, option];\n      }, []);\n\n      onChange?.(currentValue, options);\n    }\n  }, [currentValue, getOptionByValue, onChange]);\n\n  useEffect(() => {\n    if (isInitialMount.current) {\n      isInitialMount.current = false;\n    } else {\n      onDropdownVisibleChange?.();\n    }\n  }, [isSelectOpen, onDropdownVisibleChange]);\n\n  const activeValues = useMemo(() => {\n    return Array.isArray(value) ? value : isUndefined(value) ? currentValue : [value];\n  }, [currentValue, value]);\n\n  const selectDefaultStyle = getSelectDefaultStyle({\n    status,\n    disabled,\n    variant,\n    multiple: mode === \"multiple\",\n    isHover,\n    maxTagCount,\n    withPrefix: !!prefix,\n    isEmpty: activeValues.length === 0,\n  });\n\n  const filteredActiveValues = useMemo(() => {\n    return isFunction(valuesFilter) ? valuesFilter(activeValues) : activeValues;\n  }, [activeValues, valuesFilter]);\n\n  const { containerRef, isItemHidden } = useHideElements(\n    filteredActiveValues,\n    theme.spaceXS,\n    inputRef,\n    maxTagCount\n  );\n\n  const currentLabel = getLabel<Option, OptionValue>(\n    filteredActiveValues,\n    getOptionByValue,\n    optionLabelProp\n  );\n\n  const withDrawer = mode === \"multiple\" && drawer;\n  const withAutoClear = mode === \"single\" || autoClearSearchValue;\n\n  const clickHandle = () => {\n    if (disabled) {\n      return;\n    }\n\n    setIsSelectOpen((prev) => !prev);\n  };\n\n  const changeHandle = useCallback(\n    (value: OptionValue | OptionValue[]) => {\n      changeCurrentValue(value);\n\n      if (Array.isArray(value)) {\n        return;\n      }\n\n      const option = getOptionByValue(value);\n\n      if (withAutoClear) {\n        clearSearchValue();\n      }\n\n      if (option) {\n        onSelect?.(value, option);\n      }\n    },\n    [changeCurrentValue, clearSearchValue, getOptionByValue, onSelect, withAutoClear]\n  );\n\n  const closeOptionList = useCallback(() => {\n    setIsSelectOpen(false);\n  }, []);\n\n  const blurHandle = (e: FocusEvent) => {\n    const isFocusOnOptionList = refs.floating.current?.contains(e.relatedTarget);\n    const isFocusOnSearchInput = !isNull(inputRef.current) && e.relatedTarget === inputRef.current;\n    const isFocusOnControl = e.relatedTarget === controlRef.current;\n\n    if (isFocusOnOptionList || isFocusOnSearchInput || isFocusOnControl) {\n      if (showSearch) {\n        returnFocusToInput();\n      } else {\n        returnFocusToWrapper();\n      }\n\n      return;\n    }\n\n    onBlur?.(e);\n    clearSearchValue();\n    closeOptionList();\n  };\n\n  const clearSelect = useCallback(\n    (e: MouseEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n\n      clearCurrentValue();\n      onClear?.();\n    },\n    [clearCurrentValue, onClear]\n  );\n\n  const keyDownHandler = (e: KeyboardEvent) => {\n    if (e.key === \"Enter\") {\n      if (isSelectOpen) {\n        const value = getCurrentSelectingValue();\n\n        if (!value) {\n          return;\n        }\n\n        if (currentValue.includes(value)) {\n          removeValue(value);\n        } else {\n          changeCurrentValue(value);\n        }\n\n        if (withAutoClear) {\n          clearSearchValue();\n        }\n      }\n\n      clickHandle();\n    }\n\n    setIsSelectOpen(true);\n\n    onKeyControl(e);\n    onInputKeyDown?.(e);\n  };\n\n  const mouseOverHandle = () => {\n    setIsHover(true);\n  };\n\n  const mouseOutHandle = () => {\n    setIsHover(false);\n  };\n\n  const focusHandle = (e: FocusEvent) => {\n    onFocus?.(e);\n\n    if (!showSearch) {\n      return;\n    }\n\n    returnFocusToInput();\n  };\n\n  const renderTagPlaceholder = (hiddenElementsCounter: number) => {\n    if (isUndefined(maxTagPlaceholder)) {\n      return <TagPlaceholder hiddenElementsCounter={hiddenElementsCounter} />;\n    }\n\n    if (!isFunction(maxTagPlaceholder)) {\n      return <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder}</span>;\n    }\n\n    const hiddenElements = currentValue.reduce((acc: Option[], value) => {\n      const isHidden = isItemHidden.get(value);\n      const option = getOptionByValue(value);\n\n      if (!isHidden || isUndefined(option)) {\n        return acc;\n      }\n\n      acc.push(option);\n\n      return acc;\n    }, []);\n\n    return (\n      <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder(hiddenElements)}</span>\n    );\n  };\n\n  const renderLabel = (values: OptionValue[], currentLabel: string[]) => {\n    const visibleLabels = getVisibleLabels(currentLabel, maxTagCount);\n\n    const label = visibleLabels.map((label, index) => {\n      const value = values[index] as OptionValue;\n\n      if (isFunction(labelRender)) {\n        return labelRender({ label, value });\n      }\n\n      if (mode === \"single\") {\n        return label;\n      }\n\n      if (isFunction(tagRender)) {\n        return tagRender(label);\n      }\n\n      const isHidden = !!isItemHidden.get(value);\n\n      return (\n        <SelectTag<OptionValue>\n          value={value}\n          label={label}\n          removeValue={removeValue}\n          maxTagTextLength={maxTagTextLength}\n          isBorderless={variant === \"borderless\"}\n          isError={status === \"error\"}\n          disabled={disabled}\n          isHidden={isHidden}\n          onTagClose={onTagClose}\n          key={value?.toString()}\n        />\n      );\n    });\n\n    const hiddenElementsCounter = isNumber(maxTagCount)\n      ? isItemHidden.size - maxTagCount\n      : Array.from(isItemHidden.values()).reduce((acc, isHidden) => (isHidden ? acc + 1 : acc), 0);\n\n    const withTagPlaceholder =\n      !isUndefined(maxTagCount) && mode === \"multiple\" && hiddenElementsCounter > 0;\n\n    if (label.length === 0) {\n      return null;\n    }\n\n    return (\n      <>\n        {label}\n        {withTagPlaceholder && renderTagPlaceholder(hiddenElementsCounter)}\n      </>\n    );\n  };\n\n  const renderSuffix = () => {\n    if (withDrawer) {\n      return (\n        <BarsOutlined\n          onClick={clickHandle}\n          css={[selectDefaultStyle.drawerIcon(theme), styles?.drawerIcon?.(theme)]}\n        />\n      );\n    }\n\n    if (showSearch && isSelectOpen) {\n      return <SearchOutlined />;\n    }\n\n    return suffixIcon;\n  };\n\n  const renderPlaceholder = () => (\n    <span css={[selectDefaultStyle.placeholder(theme), styles?.placeholder?.(theme)]}>\n      {placeholder}\n    </span>\n  );\n\n  const withClearButton = allowClear && !!filteredActiveValues.length;\n\n  const inputValue =\n    mode === \"multiple\" || isSelectOpen\n      ? (searchValue ?? searchInputValue)\n      : currentLabel[0]?.toString();\n\n  const isEmpty = filteredActiveValues.length === 0;\n  const singleModPlaceholder = currentLabel[0] ?? placeholder ?? \"\";\n  const multipleModPlaceholder = isEmpty ? placeholder : undefined;\n\n  const searchInputPlaceholder = mode === \"single\" ? singleModPlaceholder : multipleModPlaceholder;\n\n  const lettersNumber = (inputValue?.length ?? 0) + 1;\n\n  const hasIconPrefix = typeof prefix === \"object\";\n\n  const contextValue: BaseSelectContextShape<OptionValue> = {\n    currentValue: activeValues,\n    showOptionList: open ?? isSelectOpen,\n    setValue: changeHandle,\n    closeOptionList,\n    dropdownMinWidth,\n    dropdownMaxHeight,\n    dropdownPrompt,\n    loading,\n    dropdownClassName,\n    dropdownRender,\n    dropdownMatchSelectWidth,\n    referenceOffsetWidth,\n    floatingStyles,\n    setFloating: refs.setFloating,\n    floatingRef: refs.floating,\n    getPopupContainer,\n    virtual,\n    currentSelectingIndex,\n    emptyContent,\n    notFoundContent,\n    searchValue: searchValue ?? searchInputValue,\n    showSearch,\n    mode,\n    removeValue,\n    isItemHidden,\n    getCurrentSelectingValue,\n  };\n\n  return (\n    <baseSelectContext.Provider value={contextValue}>\n      <span\n        css={[selectDefaultStyle.wrapper(theme), styles?.wrapper?.(theme)]}\n        tabIndex={1}\n        onKeyDown={keyDownHandler}\n        onMouseOver={mouseOverHandle}\n        onMouseOut={mouseOutHandle}\n        onFocus={focusHandle}\n        onBlur={blurHandle}\n        autoFocus={autoFocus}\n        ref={controlRef}\n      >\n        <span\n          css={[selectDefaultStyle.body(theme), styles?.body?.(theme)]}\n          onClick={!withDrawer ? clickHandle : undefined}\n          ref={refs.setReference}\n        >\n          <span\n            css={[selectDefaultStyle.prefixAndContent(theme), styles?.prefixAndContent?.(theme)]}\n          >\n            {prefix && (\n              <span\n                css={[selectDefaultStyle.prefix(hasIconPrefix)(theme), styles?.prefix?.(theme)]}\n              >\n                {prefix}\n              </span>\n            )}\n\n            {showSearch ? (\n              <span ref={containerRef} css={selectDefaultStyle.content(theme)}>\n                {mode === \"multiple\" && renderLabel(filteredActiveValues, currentLabel)}\n                <input\n                  css={selectDefaultStyle.searchInput(theme)}\n                  value={inputValue ?? \"\"}\n                  onChange={searchHandle}\n                  placeholder={searchInputPlaceholder?.toString()}\n                  ref={inputRef}\n                  disabled={disabled}\n                  style={getSelectSearchInputWidthStyle(\n                    mode === \"multiple\",\n                    isEmpty,\n                    lettersNumber\n                  )}\n                  data-element=\"search-input\"\n                />\n              </span>\n            ) : (\n              <span\n                ref={containerRef}\n                css={[selectDefaultStyle.content(theme), styles?.content?.(theme)]}\n              >\n                {renderLabel(filteredActiveValues, currentLabel) ?? renderPlaceholder()}\n              </span>\n            )}\n          </span>\n\n          {withClearButton && (\n            <CloseCircleFilled\n              className=\"clean-button\"\n              onClick={clearSelect}\n              css={[selectDefaultStyle.cleanIcon(theme), styles?.cleanIcon?.(theme)]}\n              data-element=\"clean-button\"\n            />\n          )}\n          <span css={[selectDefaultStyle.suffixIcon(theme), styles?.suffixIcon?.(theme)]}>\n            {renderSuffix()}\n          </span>\n        </span>\n\n        <SelectOptionList<Option, OptionValue>\n          options={filteredAndSortedOptions}\n          renderDropdownItem={renderDropdownItem}\n          optionRender={optionRender}\n          virtualizerEstimateSize={virtualizerEstimateSize}\n          styles={styles?.dropdownStyle}\n        />\n      </span>\n    </baseSelectContext.Provider>\n  );\n};\n\nexport const BaseSelect = memo(BaseSelectComponent) as typeof BaseSelectComponent;\n"]} */"], children: [
+        prefix && /* @__PURE__ */ jsx("span", { css: [selectDefaultStyle.prefix(hasIconPrefix)(theme), (_f = styles == null ? void 0 : styles.prefix) == null ? void 0 : _f.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:BaseSelectComponent;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx"],"names":[],"mappings":"AAmegB","file":"/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx","sourcesContent":["import {\n  type FocusEvent,\n  type KeyboardEvent,\n  memo,\n  type MouseEvent,\n  type PropsWithChildren,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport { getSelectDefaultStyle, getSelectSearchInputWidthStyle } from \"./BaseSelect.styles\";\nimport { useTheme } from \"hooks/useTheme\";\nimport { BarsOutlined, CloseCircleFilled, DownOutlined, SearchOutlined } from \"@infomaximum/icons\";\nimport { isFunction, isNull, isNumber, isUndefined } from \"lodash-es\";\nimport { autoUpdate, flip, offset, useFloating } from \"@floating-ui/react\";\nimport { convertSelectPlacement, getLabel, getVisibleLabels } from \"./BaseSelect.utils\";\nimport { useSearch } from \"./hooks/useSearch\";\nimport { useCurrentValue } from \"./hooks/useCurrentValue\";\nimport { SelectTag } from \"./components/SelectTag/SelectTag\";\nimport { useHideElements } from \"./hooks/useHideElements\";\nimport {\n  TagPlaceholder,\n  tagPlaceholderDataElement,\n} from \"./components/TagPlaceholder/TagPlaceholder\";\nimport type { BaseSelectOptionInterface, BaseSelectProps } from \"./BaseSelect.types\";\nimport { SelectOptionList } from \"./components/SelectOptionList/SelectOptionList\";\nimport { createBaseSelectContext, type BaseSelectContextShape } from \"./contexts/BaseSelectContext\";\n\nconst BaseSelectComponent = <Option extends BaseSelectOptionInterface<OptionValue>, OptionValue>({\n  options = [],\n  mode = \"single\",\n  variant = \"outlined\",\n  defaultValue,\n  defaultOpen = false,\n  defaultActiveFirstOption,\n  value,\n  open,\n  placeholder,\n  dropdownMinWidth = 120,\n  dropdownMaxHeight = 414,\n  allowClear = false,\n  autoFocus,\n  prefix,\n  suffixIcon = <DownOutlined />,\n  status = \"default\",\n  disabled = false,\n  dropdownPrompt,\n  loading = false,\n  dropdownClassName,\n  styles,\n  dropdownMatchSelectWidth = true,\n  placement = \"bottomLeft\",\n  virtual = true,\n  emptyContent = \"\",\n  showSearch = mode === \"single\" ? false : true,\n  searchValue,\n  notFoundContent = \"Not found\",\n  optionLabelProp = \"title\",\n  drawer = false,\n  autoClearSearchValue = true,\n  maxTagCount,\n  maxTagTextLength,\n  maxTagPlaceholder,\n  currentSelectingIndex,\n  getCurrentSelectingValue,\n  onKeyControl,\n  getOptionByValue,\n  virtualizerEstimateSize,\n  filterOptions,\n  filterSort,\n  valuesFilter,\n  dropdownRender,\n  optionRender,\n  labelRender,\n  onBlur,\n  onChange,\n  onClear,\n  onDropdownVisibleChange,\n  onFocus,\n  onInputKeyDown,\n  onSelect,\n  getPopupContainer = () => document.body,\n  onSearch,\n  tagRender,\n  onDeselect,\n  renderDropdownItem,\n  onTagClose,\n}: PropsWithChildren<BaseSelectProps<Option, OptionValue>>) => {\n  const theme = useTheme();\n  const baseSelectContext = createBaseSelectContext<OptionValue>();\n\n  const { filteredAndSortedOptions, searchInputValue, searchHandle, clearSearchValue } = useSearch<\n    Option,\n    OptionValue\n  >({\n    options,\n    searchValue,\n    onSearch,\n    filterSort,\n    filterOptions,\n  });\n\n  const { currentValue, changeCurrentValue, removeValue, clearCurrentValue } = useCurrentValue(\n    mode,\n    defaultValue,\n    defaultActiveFirstOption,\n    options,\n    onDeselect\n  );\n\n  const [isSelectOpen, setIsSelectOpen] = useState(defaultOpen);\n  const [isHover, setIsHover] = useState(false);\n\n  const isInitialMount = useRef(true);\n  const controlRef = useRef<HTMLSpanElement | null>(null);\n  const inputRef = useRef<HTMLInputElement | null>(null);\n\n  const referenceOffsetWidth = controlRef.current?.offsetWidth;\n\n  const { refs, floatingStyles } = useFloating<HTMLSpanElement>({\n    whileElementsMounted: autoUpdate,\n    placement: convertSelectPlacement(placement),\n    middleware: [offset(4), flip()],\n  });\n\n  const returnFocusToWrapper = useCallback(() => {\n    setTimeout(() => {\n      controlRef.current?.focus();\n    });\n  }, []);\n\n  const returnFocusToInput = useCallback(() => {\n    setTimeout(() => {\n      inputRef.current?.focus();\n    });\n  }, []);\n\n  useEffect(() => {\n    if (!isInitialMount.current) {\n      const options = currentValue.reduce((acc: Option[], value) => {\n        const option = getOptionByValue(value);\n\n        if (isUndefined(option)) {\n          return acc;\n        }\n\n        return [...acc, option];\n      }, []);\n\n      onChange?.(currentValue, options);\n    }\n  }, [currentValue, getOptionByValue, onChange]);\n\n  useEffect(() => {\n    if (isInitialMount.current) {\n      isInitialMount.current = false;\n    } else {\n      onDropdownVisibleChange?.();\n    }\n  }, [isSelectOpen, onDropdownVisibleChange]);\n\n  const activeValues = useMemo(() => {\n    return Array.isArray(value) ? value : isUndefined(value) ? currentValue : [value];\n  }, [currentValue, value]);\n\n  const selectDefaultStyle = getSelectDefaultStyle({\n    status,\n    disabled,\n    variant,\n    multiple: mode === \"multiple\",\n    isHover,\n    maxTagCount,\n    withPrefix: !!prefix,\n    isEmpty: activeValues.length === 0,\n  });\n\n  const filteredActiveValues = useMemo(() => {\n    return isFunction(valuesFilter) ? valuesFilter(activeValues) : activeValues;\n  }, [activeValues, valuesFilter]);\n\n  const { containerRef, isItemHidden } = useHideElements(\n    filteredActiveValues,\n    theme.spaceXS,\n    inputRef,\n    maxTagCount\n  );\n\n  const currentLabel = getLabel<Option, OptionValue>(\n    filteredActiveValues,\n    getOptionByValue,\n    optionLabelProp\n  );\n\n  const withDrawer = mode === \"multiple\" && drawer;\n  const withAutoClear = mode === \"single\" || autoClearSearchValue;\n\n  const clickHandle = () => {\n    if (disabled) {\n      return;\n    }\n\n    setIsSelectOpen((prev) => !prev);\n  };\n\n  const changeHandle = useCallback(\n    (value: OptionValue | OptionValue[]) => {\n      changeCurrentValue(value);\n\n      if (Array.isArray(value)) {\n        return;\n      }\n\n      const option = getOptionByValue(value);\n\n      if (withAutoClear) {\n        clearSearchValue();\n      }\n\n      if (option) {\n        onSelect?.(value, option);\n      }\n    },\n    [changeCurrentValue, clearSearchValue, getOptionByValue, onSelect, withAutoClear]\n  );\n\n  const closeOptionList = useCallback(() => {\n    setIsSelectOpen(false);\n  }, []);\n\n  const blurHandle = (e: FocusEvent) => {\n    const isFocusOnOptionList = refs.floating.current?.contains(e.relatedTarget);\n    const isFocusOnSearchInput = !isNull(inputRef.current) && e.relatedTarget === inputRef.current;\n    const isFocusOnControl = e.relatedTarget === controlRef.current;\n\n    if (isFocusOnOptionList || isFocusOnSearchInput || isFocusOnControl) {\n      if (showSearch) {\n        returnFocusToInput();\n      } else {\n        returnFocusToWrapper();\n      }\n\n      return;\n    }\n\n    onBlur?.(e);\n    clearSearchValue();\n    closeOptionList();\n  };\n\n  const clearSelect = useCallback(\n    (e: MouseEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n\n      clearCurrentValue();\n      onClear?.();\n    },\n    [clearCurrentValue, onClear]\n  );\n\n  const keyDownHandler = (e: KeyboardEvent) => {\n    if (e.key === \"Enter\") {\n      if (isSelectOpen) {\n        const value = getCurrentSelectingValue();\n\n        if (!value) {\n          return;\n        }\n\n        if (currentValue.includes(value)) {\n          removeValue(value);\n        } else {\n          changeCurrentValue(value);\n        }\n\n        if (withAutoClear) {\n          clearSearchValue();\n        }\n      }\n\n      clickHandle();\n    }\n\n    setIsSelectOpen(true);\n\n    onKeyControl(e);\n    onInputKeyDown?.(e);\n  };\n\n  const mouseOverHandle = () => {\n    setIsHover(true);\n  };\n\n  const mouseOutHandle = () => {\n    setIsHover(false);\n  };\n\n  const focusHandle = (e: FocusEvent) => {\n    onFocus?.(e);\n\n    if (!showSearch) {\n      return;\n    }\n\n    returnFocusToInput();\n  };\n\n  const renderTagPlaceholder = (hiddenElementsCounter: number) => {\n    if (isUndefined(maxTagPlaceholder)) {\n      return <TagPlaceholder hiddenElementsCounter={hiddenElementsCounter} />;\n    }\n\n    if (!isFunction(maxTagPlaceholder)) {\n      return <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder}</span>;\n    }\n\n    const hiddenElements = currentValue.reduce((acc: Option[], value) => {\n      const isHidden = isItemHidden.get(value);\n      const option = getOptionByValue(value);\n\n      if (!isHidden || isUndefined(option)) {\n        return acc;\n      }\n\n      acc.push(option);\n\n      return acc;\n    }, []);\n\n    return (\n      <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder(hiddenElements)}</span>\n    );\n  };\n\n  const renderLabel = (values: OptionValue[], currentLabel: string[]) => {\n    const visibleLabels = getVisibleLabels(currentLabel, maxTagCount);\n\n    const label = visibleLabels.map((label, index) => {\n      const value = values[index] as OptionValue;\n\n      if (isFunction(labelRender)) {\n        return labelRender({ label, value });\n      }\n\n      if (mode === \"single\") {\n        return label;\n      }\n\n      if (isFunction(tagRender)) {\n        return tagRender(label);\n      }\n\n      const isHidden = !!isItemHidden.get(value);\n\n      return (\n        <SelectTag<OptionValue>\n          value={value}\n          label={label}\n          removeValue={removeValue}\n          maxTagTextLength={maxTagTextLength}\n          isBorderless={variant === \"borderless\"}\n          isError={status === \"error\"}\n          disabled={disabled}\n          isHidden={isHidden}\n          onTagClose={onTagClose}\n          key={value?.toString()}\n        />\n      );\n    });\n\n    const hiddenElementsCounter = isNumber(maxTagCount)\n      ? isItemHidden.size - maxTagCount\n      : Array.from(isItemHidden.values()).reduce((acc, isHidden) => (isHidden ? acc + 1 : acc), 0);\n\n    const withTagPlaceholder =\n      !isUndefined(maxTagCount) && mode === \"multiple\" && hiddenElementsCounter > 0;\n\n    if (label.length === 0) {\n      return null;\n    }\n\n    return (\n      <>\n        {label}\n        {withTagPlaceholder && renderTagPlaceholder(hiddenElementsCounter)}\n      </>\n    );\n  };\n\n  const renderSuffix = () => {\n    if (withDrawer) {\n      return (\n        <BarsOutlined\n          onClick={clickHandle}\n          css={[selectDefaultStyle.drawerIcon(theme), styles?.drawerIcon?.(theme)]}\n        />\n      );\n    }\n\n    if (showSearch && isSelectOpen) {\n      return <SearchOutlined />;\n    }\n\n    return suffixIcon;\n  };\n\n  const renderPlaceholder = () => (\n    <span css={[selectDefaultStyle.placeholder(theme), styles?.placeholder?.(theme)]}>\n      {placeholder}\n    </span>\n  );\n\n  const withClearButton = allowClear && !!filteredActiveValues.length;\n\n  const inputValue =\n    mode === \"multiple\" || isSelectOpen\n      ? (searchValue ?? searchInputValue)\n      : currentLabel[0]?.toString();\n\n  const isEmpty = filteredActiveValues.length === 0;\n  const singleModPlaceholder = currentLabel[0] ?? placeholder ?? \"\";\n  const multipleModPlaceholder = isEmpty ? placeholder : undefined;\n\n  const searchInputPlaceholder = mode === \"single\" ? singleModPlaceholder : multipleModPlaceholder;\n\n  const lettersNumber = (inputValue?.length ?? 0) + 1;\n\n  const hasIconPrefix = typeof prefix === \"object\";\n\n  const contextValue: BaseSelectContextShape<OptionValue> = {\n    currentValue: activeValues,\n    showOptionList: open ?? isSelectOpen,\n    setValue: changeHandle,\n    closeOptionList,\n    dropdownMinWidth,\n    dropdownMaxHeight,\n    dropdownPrompt,\n    loading,\n    dropdownClassName,\n    dropdownRender,\n    dropdownMatchSelectWidth,\n    referenceOffsetWidth,\n    floatingStyles,\n    setFloating: refs.setFloating,\n    floatingRef: refs.floating,\n    getPopupContainer,\n    virtual,\n    currentSelectingIndex,\n    emptyContent,\n    notFoundContent,\n    searchValue: searchValue ?? searchInputValue,\n    showSearch,\n    mode,\n    removeValue,\n    isItemHidden,\n    getCurrentSelectingValue,\n  };\n\n  return (\n    <baseSelectContext.Provider value={contextValue}>\n      <span\n        css={[selectDefaultStyle.wrapper(theme), styles?.wrapper?.(theme)]}\n        tabIndex={1}\n        onKeyDown={keyDownHandler}\n        onMouseOver={mouseOverHandle}\n        onMouseOut={mouseOutHandle}\n        onFocus={focusHandle}\n        onBlur={blurHandle}\n        autoFocus={autoFocus}\n        ref={controlRef}\n      >\n        <span\n          css={[selectDefaultStyle.body(theme), styles?.body?.(theme)]}\n          onClick={!withDrawer ? clickHandle : undefined}\n          ref={refs.setReference}\n        >\n          <span\n            css={[selectDefaultStyle.prefixAndContent(theme), styles?.prefixAndContent?.(theme)]}\n          >\n            {prefix && (\n              <span\n                css={[selectDefaultStyle.prefix(hasIconPrefix)(theme), styles?.prefix?.(theme)]}\n              >\n                {prefix}\n              </span>\n            )}\n\n            {showSearch ? (\n              <span ref={containerRef} css={selectDefaultStyle.content(theme)}>\n                {mode === \"multiple\" && renderLabel(filteredActiveValues, currentLabel)}\n                <input\n                  css={selectDefaultStyle.searchInput(theme)}\n                  value={inputValue ?? \"\"}\n                  onChange={searchHandle}\n                  placeholder={searchInputPlaceholder?.toString()}\n                  ref={inputRef}\n                  disabled={disabled}\n                  style={getSelectSearchInputWidthStyle(\n                    mode === \"multiple\",\n                    isEmpty,\n                    lettersNumber\n                  )}\n                  data-element=\"search-input\"\n                />\n              </span>\n            ) : (\n              <span\n                ref={containerRef}\n                css={[selectDefaultStyle.content(theme), styles?.content?.(theme)]}\n              >\n                {renderLabel(filteredActiveValues, currentLabel) ?? renderPlaceholder()}\n              </span>\n            )}\n          </span>\n\n          {withClearButton && (\n            <CloseCircleFilled\n              className=\"clean-button\"\n              onClick={clearSelect}\n              css={[selectDefaultStyle.cleanIcon(theme), styles?.cleanIcon?.(theme)]}\n              data-element=\"clean-button\"\n            />\n          )}\n          <span css={[selectDefaultStyle.suffixIcon(theme), styles?.suffixIcon?.(theme)]}>\n            {renderSuffix()}\n          </span>\n        </span>\n\n        <SelectOptionList<Option, OptionValue>\n          options={filteredAndSortedOptions}\n          renderDropdownItem={renderDropdownItem}\n          optionRender={optionRender}\n          virtualizerEstimateSize={virtualizerEstimateSize}\n          styles={styles?.dropdownStyle}\n        />\n      </span>\n    </baseSelectContext.Provider>\n  );\n};\n\nexport const BaseSelect = memo(BaseSelectComponent) as typeof BaseSelectComponent;\n"]} */"], children: prefix }),
+        showSearch ? /* @__PURE__ */ jsxs("span", { ref: containerRef, css: selectDefaultStyle.content(theme), children: [
+          mode === "multiple" && renderLabel(filteredActiveValues, currentLabel),
+          /* @__PURE__ */ jsx("input", { css: selectDefaultStyle.searchInput(theme), value: inputValue ?? "", onChange: searchHandle, placeholder: searchInputPlaceholder == null ? void 0 : searchInputPlaceholder.toString(), ref: inputRef, disabled, style: getSelectSearchInputWidthStyle(mode === "multiple", isEmpty, lettersNumber), "data-element": "search-input" })
+        ] }) : /* @__PURE__ */ jsx("span", { ref: containerRef, css: [selectDefaultStyle.content(theme), (_g = styles == null ? void 0 : styles.content) == null ? void 0 : _g.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:BaseSelectComponent;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx"],"names":[],"mappings":"AA8fgB","file":"/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx","sourcesContent":["import {\n  type FocusEvent,\n  type KeyboardEvent,\n  memo,\n  type MouseEvent,\n  type PropsWithChildren,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport { getSelectDefaultStyle, getSelectSearchInputWidthStyle } from \"./BaseSelect.styles\";\nimport { useTheme } from \"hooks/useTheme\";\nimport { BarsOutlined, CloseCircleFilled, DownOutlined, SearchOutlined } from \"@infomaximum/icons\";\nimport { isFunction, isNull, isNumber, isUndefined } from \"lodash-es\";\nimport { autoUpdate, flip, offset, useFloating } from \"@floating-ui/react\";\nimport { convertSelectPlacement, getLabel, getVisibleLabels } from \"./BaseSelect.utils\";\nimport { useSearch } from \"./hooks/useSearch\";\nimport { useCurrentValue } from \"./hooks/useCurrentValue\";\nimport { SelectTag } from \"./components/SelectTag/SelectTag\";\nimport { useHideElements } from \"./hooks/useHideElements\";\nimport {\n  TagPlaceholder,\n  tagPlaceholderDataElement,\n} from \"./components/TagPlaceholder/TagPlaceholder\";\nimport type { BaseSelectOptionInterface, BaseSelectProps } from \"./BaseSelect.types\";\nimport { SelectOptionList } from \"./components/SelectOptionList/SelectOptionList\";\nimport { createBaseSelectContext, type BaseSelectContextShape } from \"./contexts/BaseSelectContext\";\n\nconst BaseSelectComponent = <Option extends BaseSelectOptionInterface<OptionValue>, OptionValue>({\n  options = [],\n  mode = \"single\",\n  variant = \"outlined\",\n  defaultValue,\n  defaultOpen = false,\n  defaultActiveFirstOption,\n  value,\n  open,\n  placeholder,\n  dropdownMinWidth = 120,\n  dropdownMaxHeight = 414,\n  allowClear = false,\n  autoFocus,\n  prefix,\n  suffixIcon = <DownOutlined />,\n  status = \"default\",\n  disabled = false,\n  dropdownPrompt,\n  loading = false,\n  dropdownClassName,\n  styles,\n  dropdownMatchSelectWidth = true,\n  placement = \"bottomLeft\",\n  virtual = true,\n  emptyContent = \"\",\n  showSearch = mode === \"single\" ? false : true,\n  searchValue,\n  notFoundContent = \"Not found\",\n  optionLabelProp = \"title\",\n  drawer = false,\n  autoClearSearchValue = true,\n  maxTagCount,\n  maxTagTextLength,\n  maxTagPlaceholder,\n  currentSelectingIndex,\n  getCurrentSelectingValue,\n  onKeyControl,\n  getOptionByValue,\n  virtualizerEstimateSize,\n  filterOptions,\n  filterSort,\n  valuesFilter,\n  dropdownRender,\n  optionRender,\n  labelRender,\n  onBlur,\n  onChange,\n  onClear,\n  onDropdownVisibleChange,\n  onFocus,\n  onInputKeyDown,\n  onSelect,\n  getPopupContainer = () => document.body,\n  onSearch,\n  tagRender,\n  onDeselect,\n  renderDropdownItem,\n  onTagClose,\n}: PropsWithChildren<BaseSelectProps<Option, OptionValue>>) => {\n  const theme = useTheme();\n  const baseSelectContext = createBaseSelectContext<OptionValue>();\n\n  const { filteredAndSortedOptions, searchInputValue, searchHandle, clearSearchValue } = useSearch<\n    Option,\n    OptionValue\n  >({\n    options,\n    searchValue,\n    onSearch,\n    filterSort,\n    filterOptions,\n  });\n\n  const { currentValue, changeCurrentValue, removeValue, clearCurrentValue } = useCurrentValue(\n    mode,\n    defaultValue,\n    defaultActiveFirstOption,\n    options,\n    onDeselect\n  );\n\n  const [isSelectOpen, setIsSelectOpen] = useState(defaultOpen);\n  const [isHover, setIsHover] = useState(false);\n\n  const isInitialMount = useRef(true);\n  const controlRef = useRef<HTMLSpanElement | null>(null);\n  const inputRef = useRef<HTMLInputElement | null>(null);\n\n  const referenceOffsetWidth = controlRef.current?.offsetWidth;\n\n  const { refs, floatingStyles } = useFloating<HTMLSpanElement>({\n    whileElementsMounted: autoUpdate,\n    placement: convertSelectPlacement(placement),\n    middleware: [offset(4), flip()],\n  });\n\n  const returnFocusToWrapper = useCallback(() => {\n    setTimeout(() => {\n      controlRef.current?.focus();\n    });\n  }, []);\n\n  const returnFocusToInput = useCallback(() => {\n    setTimeout(() => {\n      inputRef.current?.focus();\n    });\n  }, []);\n\n  useEffect(() => {\n    if (!isInitialMount.current) {\n      const options = currentValue.reduce((acc: Option[], value) => {\n        const option = getOptionByValue(value);\n\n        if (isUndefined(option)) {\n          return acc;\n        }\n\n        return [...acc, option];\n      }, []);\n\n      onChange?.(currentValue, options);\n    }\n  }, [currentValue, getOptionByValue, onChange]);\n\n  useEffect(() => {\n    if (isInitialMount.current) {\n      isInitialMount.current = false;\n    } else {\n      onDropdownVisibleChange?.();\n    }\n  }, [isSelectOpen, onDropdownVisibleChange]);\n\n  const activeValues = useMemo(() => {\n    return Array.isArray(value) ? value : isUndefined(value) ? currentValue : [value];\n  }, [currentValue, value]);\n\n  const selectDefaultStyle = getSelectDefaultStyle({\n    status,\n    disabled,\n    variant,\n    multiple: mode === \"multiple\",\n    isHover,\n    maxTagCount,\n    withPrefix: !!prefix,\n    isEmpty: activeValues.length === 0,\n  });\n\n  const filteredActiveValues = useMemo(() => {\n    return isFunction(valuesFilter) ? valuesFilter(activeValues) : activeValues;\n  }, [activeValues, valuesFilter]);\n\n  const { containerRef, isItemHidden } = useHideElements(\n    filteredActiveValues,\n    theme.spaceXS,\n    inputRef,\n    maxTagCount\n  );\n\n  const currentLabel = getLabel<Option, OptionValue>(\n    filteredActiveValues,\n    getOptionByValue,\n    optionLabelProp\n  );\n\n  const withDrawer = mode === \"multiple\" && drawer;\n  const withAutoClear = mode === \"single\" || autoClearSearchValue;\n\n  const clickHandle = () => {\n    if (disabled) {\n      return;\n    }\n\n    setIsSelectOpen((prev) => !prev);\n  };\n\n  const changeHandle = useCallback(\n    (value: OptionValue | OptionValue[]) => {\n      changeCurrentValue(value);\n\n      if (Array.isArray(value)) {\n        return;\n      }\n\n      const option = getOptionByValue(value);\n\n      if (withAutoClear) {\n        clearSearchValue();\n      }\n\n      if (option) {\n        onSelect?.(value, option);\n      }\n    },\n    [changeCurrentValue, clearSearchValue, getOptionByValue, onSelect, withAutoClear]\n  );\n\n  const closeOptionList = useCallback(() => {\n    setIsSelectOpen(false);\n  }, []);\n\n  const blurHandle = (e: FocusEvent) => {\n    const isFocusOnOptionList = refs.floating.current?.contains(e.relatedTarget);\n    const isFocusOnSearchInput = !isNull(inputRef.current) && e.relatedTarget === inputRef.current;\n    const isFocusOnControl = e.relatedTarget === controlRef.current;\n\n    if (isFocusOnOptionList || isFocusOnSearchInput || isFocusOnControl) {\n      if (showSearch) {\n        returnFocusToInput();\n      } else {\n        returnFocusToWrapper();\n      }\n\n      return;\n    }\n\n    onBlur?.(e);\n    clearSearchValue();\n    closeOptionList();\n  };\n\n  const clearSelect = useCallback(\n    (e: MouseEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n\n      clearCurrentValue();\n      onClear?.();\n    },\n    [clearCurrentValue, onClear]\n  );\n\n  const keyDownHandler = (e: KeyboardEvent) => {\n    if (e.key === \"Enter\") {\n      if (isSelectOpen) {\n        const value = getCurrentSelectingValue();\n\n        if (!value) {\n          return;\n        }\n\n        if (currentValue.includes(value)) {\n          removeValue(value);\n        } else {\n          changeCurrentValue(value);\n        }\n\n        if (withAutoClear) {\n          clearSearchValue();\n        }\n      }\n\n      clickHandle();\n    }\n\n    setIsSelectOpen(true);\n\n    onKeyControl(e);\n    onInputKeyDown?.(e);\n  };\n\n  const mouseOverHandle = () => {\n    setIsHover(true);\n  };\n\n  const mouseOutHandle = () => {\n    setIsHover(false);\n  };\n\n  const focusHandle = (e: FocusEvent) => {\n    onFocus?.(e);\n\n    if (!showSearch) {\n      return;\n    }\n\n    returnFocusToInput();\n  };\n\n  const renderTagPlaceholder = (hiddenElementsCounter: number) => {\n    if (isUndefined(maxTagPlaceholder)) {\n      return <TagPlaceholder hiddenElementsCounter={hiddenElementsCounter} />;\n    }\n\n    if (!isFunction(maxTagPlaceholder)) {\n      return <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder}</span>;\n    }\n\n    const hiddenElements = currentValue.reduce((acc: Option[], value) => {\n      const isHidden = isItemHidden.get(value);\n      const option = getOptionByValue(value);\n\n      if (!isHidden || isUndefined(option)) {\n        return acc;\n      }\n\n      acc.push(option);\n\n      return acc;\n    }, []);\n\n    return (\n      <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder(hiddenElements)}</span>\n    );\n  };\n\n  const renderLabel = (values: OptionValue[], currentLabel: string[]) => {\n    const visibleLabels = getVisibleLabels(currentLabel, maxTagCount);\n\n    const label = visibleLabels.map((label, index) => {\n      const value = values[index] as OptionValue;\n\n      if (isFunction(labelRender)) {\n        return labelRender({ label, value });\n      }\n\n      if (mode === \"single\") {\n        return label;\n      }\n\n      if (isFunction(tagRender)) {\n        return tagRender(label);\n      }\n\n      const isHidden = !!isItemHidden.get(value);\n\n      return (\n        <SelectTag<OptionValue>\n          value={value}\n          label={label}\n          removeValue={removeValue}\n          maxTagTextLength={maxTagTextLength}\n          isBorderless={variant === \"borderless\"}\n          isError={status === \"error\"}\n          disabled={disabled}\n          isHidden={isHidden}\n          onTagClose={onTagClose}\n          key={value?.toString()}\n        />\n      );\n    });\n\n    const hiddenElementsCounter = isNumber(maxTagCount)\n      ? isItemHidden.size - maxTagCount\n      : Array.from(isItemHidden.values()).reduce((acc, isHidden) => (isHidden ? acc + 1 : acc), 0);\n\n    const withTagPlaceholder =\n      !isUndefined(maxTagCount) && mode === \"multiple\" && hiddenElementsCounter > 0;\n\n    if (label.length === 0) {\n      return null;\n    }\n\n    return (\n      <>\n        {label}\n        {withTagPlaceholder && renderTagPlaceholder(hiddenElementsCounter)}\n      </>\n    );\n  };\n\n  const renderSuffix = () => {\n    if (withDrawer) {\n      return (\n        <BarsOutlined\n          onClick={clickHandle}\n          css={[selectDefaultStyle.drawerIcon(theme), styles?.drawerIcon?.(theme)]}\n        />\n      );\n    }\n\n    if (showSearch && isSelectOpen) {\n      return <SearchOutlined />;\n    }\n\n    return suffixIcon;\n  };\n\n  const renderPlaceholder = () => (\n    <span css={[selectDefaultStyle.placeholder(theme), styles?.placeholder?.(theme)]}>\n      {placeholder}\n    </span>\n  );\n\n  const withClearButton = allowClear && !!filteredActiveValues.length;\n\n  const inputValue =\n    mode === \"multiple\" || isSelectOpen\n      ? (searchValue ?? searchInputValue)\n      : currentLabel[0]?.toString();\n\n  const isEmpty = filteredActiveValues.length === 0;\n  const singleModPlaceholder = currentLabel[0] ?? placeholder ?? \"\";\n  const multipleModPlaceholder = isEmpty ? placeholder : undefined;\n\n  const searchInputPlaceholder = mode === \"single\" ? singleModPlaceholder : multipleModPlaceholder;\n\n  const lettersNumber = (inputValue?.length ?? 0) + 1;\n\n  const hasIconPrefix = typeof prefix === \"object\";\n\n  const contextValue: BaseSelectContextShape<OptionValue> = {\n    currentValue: activeValues,\n    showOptionList: open ?? isSelectOpen,\n    setValue: changeHandle,\n    closeOptionList,\n    dropdownMinWidth,\n    dropdownMaxHeight,\n    dropdownPrompt,\n    loading,\n    dropdownClassName,\n    dropdownRender,\n    dropdownMatchSelectWidth,\n    referenceOffsetWidth,\n    floatingStyles,\n    setFloating: refs.setFloating,\n    floatingRef: refs.floating,\n    getPopupContainer,\n    virtual,\n    currentSelectingIndex,\n    emptyContent,\n    notFoundContent,\n    searchValue: searchValue ?? searchInputValue,\n    showSearch,\n    mode,\n    removeValue,\n    isItemHidden,\n    getCurrentSelectingValue,\n  };\n\n  return (\n    <baseSelectContext.Provider value={contextValue}>\n      <span\n        css={[selectDefaultStyle.wrapper(theme), styles?.wrapper?.(theme)]}\n        tabIndex={1}\n        onKeyDown={keyDownHandler}\n        onMouseOver={mouseOverHandle}\n        onMouseOut={mouseOutHandle}\n        onFocus={focusHandle}\n        onBlur={blurHandle}\n        autoFocus={autoFocus}\n        ref={controlRef}\n      >\n        <span\n          css={[selectDefaultStyle.body(theme), styles?.body?.(theme)]}\n          onClick={!withDrawer ? clickHandle : undefined}\n          ref={refs.setReference}\n        >\n          <span\n            css={[selectDefaultStyle.prefixAndContent(theme), styles?.prefixAndContent?.(theme)]}\n          >\n            {prefix && (\n              <span\n                css={[selectDefaultStyle.prefix(hasIconPrefix)(theme), styles?.prefix?.(theme)]}\n              >\n                {prefix}\n              </span>\n            )}\n\n            {showSearch ? (\n              <span ref={containerRef} css={selectDefaultStyle.content(theme)}>\n                {mode === \"multiple\" && renderLabel(filteredActiveValues, currentLabel)}\n                <input\n                  css={selectDefaultStyle.searchInput(theme)}\n                  value={inputValue ?? \"\"}\n                  onChange={searchHandle}\n                  placeholder={searchInputPlaceholder?.toString()}\n                  ref={inputRef}\n                  disabled={disabled}\n                  style={getSelectSearchInputWidthStyle(\n                    mode === \"multiple\",\n                    isEmpty,\n                    lettersNumber\n                  )}\n                  data-element=\"search-input\"\n                />\n              </span>\n            ) : (\n              <span\n                ref={containerRef}\n                css={[selectDefaultStyle.content(theme), styles?.content?.(theme)]}\n              >\n                {renderLabel(filteredActiveValues, currentLabel) ?? renderPlaceholder()}\n              </span>\n            )}\n          </span>\n\n          {withClearButton && (\n            <CloseCircleFilled\n              className=\"clean-button\"\n              onClick={clearSelect}\n              css={[selectDefaultStyle.cleanIcon(theme), styles?.cleanIcon?.(theme)]}\n              data-element=\"clean-button\"\n            />\n          )}\n          <span css={[selectDefaultStyle.suffixIcon(theme), styles?.suffixIcon?.(theme)]}>\n            {renderSuffix()}\n          </span>\n        </span>\n\n        <SelectOptionList<Option, OptionValue>\n          options={filteredAndSortedOptions}\n          renderDropdownItem={renderDropdownItem}\n          optionRender={optionRender}\n          virtualizerEstimateSize={virtualizerEstimateSize}\n          styles={styles?.dropdownStyle}\n        />\n      </span>\n    </baseSelectContext.Provider>\n  );\n};\n\nexport const BaseSelect = memo(BaseSelectComponent) as typeof BaseSelectComponent;\n"]} */"], children: renderLabel(filteredActiveValues, currentLabel) ?? renderPlaceholder() })
+      ] }),
+      withClearButton && /* @__PURE__ */ jsx(CloseCircleFilled, { className: "clean-button", onClick: clearSelect, css: [selectDefaultStyle.cleanIcon(theme), (_h = styles == null ? void 0 : styles.cleanIcon) == null ? void 0 : _h.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:BaseSelectComponent;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx"],"names":[],"mappings":"AAygBc","file":"/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx","sourcesContent":["import {\n  type FocusEvent,\n  type KeyboardEvent,\n  memo,\n  type MouseEvent,\n  type PropsWithChildren,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport { getSelectDefaultStyle, getSelectSearchInputWidthStyle } from \"./BaseSelect.styles\";\nimport { useTheme } from \"hooks/useTheme\";\nimport { BarsOutlined, CloseCircleFilled, DownOutlined, SearchOutlined } from \"@infomaximum/icons\";\nimport { isFunction, isNull, isNumber, isUndefined } from \"lodash-es\";\nimport { autoUpdate, flip, offset, useFloating } from \"@floating-ui/react\";\nimport { convertSelectPlacement, getLabel, getVisibleLabels } from \"./BaseSelect.utils\";\nimport { useSearch } from \"./hooks/useSearch\";\nimport { useCurrentValue } from \"./hooks/useCurrentValue\";\nimport { SelectTag } from \"./components/SelectTag/SelectTag\";\nimport { useHideElements } from \"./hooks/useHideElements\";\nimport {\n  TagPlaceholder,\n  tagPlaceholderDataElement,\n} from \"./components/TagPlaceholder/TagPlaceholder\";\nimport type { BaseSelectOptionInterface, BaseSelectProps } from \"./BaseSelect.types\";\nimport { SelectOptionList } from \"./components/SelectOptionList/SelectOptionList\";\nimport { createBaseSelectContext, type BaseSelectContextShape } from \"./contexts/BaseSelectContext\";\n\nconst BaseSelectComponent = <Option extends BaseSelectOptionInterface<OptionValue>, OptionValue>({\n  options = [],\n  mode = \"single\",\n  variant = \"outlined\",\n  defaultValue,\n  defaultOpen = false,\n  defaultActiveFirstOption,\n  value,\n  open,\n  placeholder,\n  dropdownMinWidth = 120,\n  dropdownMaxHeight = 414,\n  allowClear = false,\n  autoFocus,\n  prefix,\n  suffixIcon = <DownOutlined />,\n  status = \"default\",\n  disabled = false,\n  dropdownPrompt,\n  loading = false,\n  dropdownClassName,\n  styles,\n  dropdownMatchSelectWidth = true,\n  placement = \"bottomLeft\",\n  virtual = true,\n  emptyContent = \"\",\n  showSearch = mode === \"single\" ? false : true,\n  searchValue,\n  notFoundContent = \"Not found\",\n  optionLabelProp = \"title\",\n  drawer = false,\n  autoClearSearchValue = true,\n  maxTagCount,\n  maxTagTextLength,\n  maxTagPlaceholder,\n  currentSelectingIndex,\n  getCurrentSelectingValue,\n  onKeyControl,\n  getOptionByValue,\n  virtualizerEstimateSize,\n  filterOptions,\n  filterSort,\n  valuesFilter,\n  dropdownRender,\n  optionRender,\n  labelRender,\n  onBlur,\n  onChange,\n  onClear,\n  onDropdownVisibleChange,\n  onFocus,\n  onInputKeyDown,\n  onSelect,\n  getPopupContainer = () => document.body,\n  onSearch,\n  tagRender,\n  onDeselect,\n  renderDropdownItem,\n  onTagClose,\n}: PropsWithChildren<BaseSelectProps<Option, OptionValue>>) => {\n  const theme = useTheme();\n  const baseSelectContext = createBaseSelectContext<OptionValue>();\n\n  const { filteredAndSortedOptions, searchInputValue, searchHandle, clearSearchValue } = useSearch<\n    Option,\n    OptionValue\n  >({\n    options,\n    searchValue,\n    onSearch,\n    filterSort,\n    filterOptions,\n  });\n\n  const { currentValue, changeCurrentValue, removeValue, clearCurrentValue } = useCurrentValue(\n    mode,\n    defaultValue,\n    defaultActiveFirstOption,\n    options,\n    onDeselect\n  );\n\n  const [isSelectOpen, setIsSelectOpen] = useState(defaultOpen);\n  const [isHover, setIsHover] = useState(false);\n\n  const isInitialMount = useRef(true);\n  const controlRef = useRef<HTMLSpanElement | null>(null);\n  const inputRef = useRef<HTMLInputElement | null>(null);\n\n  const referenceOffsetWidth = controlRef.current?.offsetWidth;\n\n  const { refs, floatingStyles } = useFloating<HTMLSpanElement>({\n    whileElementsMounted: autoUpdate,\n    placement: convertSelectPlacement(placement),\n    middleware: [offset(4), flip()],\n  });\n\n  const returnFocusToWrapper = useCallback(() => {\n    setTimeout(() => {\n      controlRef.current?.focus();\n    });\n  }, []);\n\n  const returnFocusToInput = useCallback(() => {\n    setTimeout(() => {\n      inputRef.current?.focus();\n    });\n  }, []);\n\n  useEffect(() => {\n    if (!isInitialMount.current) {\n      const options = currentValue.reduce((acc: Option[], value) => {\n        const option = getOptionByValue(value);\n\n        if (isUndefined(option)) {\n          return acc;\n        }\n\n        return [...acc, option];\n      }, []);\n\n      onChange?.(currentValue, options);\n    }\n  }, [currentValue, getOptionByValue, onChange]);\n\n  useEffect(() => {\n    if (isInitialMount.current) {\n      isInitialMount.current = false;\n    } else {\n      onDropdownVisibleChange?.();\n    }\n  }, [isSelectOpen, onDropdownVisibleChange]);\n\n  const activeValues = useMemo(() => {\n    return Array.isArray(value) ? value : isUndefined(value) ? currentValue : [value];\n  }, [currentValue, value]);\n\n  const selectDefaultStyle = getSelectDefaultStyle({\n    status,\n    disabled,\n    variant,\n    multiple: mode === \"multiple\",\n    isHover,\n    maxTagCount,\n    withPrefix: !!prefix,\n    isEmpty: activeValues.length === 0,\n  });\n\n  const filteredActiveValues = useMemo(() => {\n    return isFunction(valuesFilter) ? valuesFilter(activeValues) : activeValues;\n  }, [activeValues, valuesFilter]);\n\n  const { containerRef, isItemHidden } = useHideElements(\n    filteredActiveValues,\n    theme.spaceXS,\n    inputRef,\n    maxTagCount\n  );\n\n  const currentLabel = getLabel<Option, OptionValue>(\n    filteredActiveValues,\n    getOptionByValue,\n    optionLabelProp\n  );\n\n  const withDrawer = mode === \"multiple\" && drawer;\n  const withAutoClear = mode === \"single\" || autoClearSearchValue;\n\n  const clickHandle = () => {\n    if (disabled) {\n      return;\n    }\n\n    setIsSelectOpen((prev) => !prev);\n  };\n\n  const changeHandle = useCallback(\n    (value: OptionValue | OptionValue[]) => {\n      changeCurrentValue(value);\n\n      if (Array.isArray(value)) {\n        return;\n      }\n\n      const option = getOptionByValue(value);\n\n      if (withAutoClear) {\n        clearSearchValue();\n      }\n\n      if (option) {\n        onSelect?.(value, option);\n      }\n    },\n    [changeCurrentValue, clearSearchValue, getOptionByValue, onSelect, withAutoClear]\n  );\n\n  const closeOptionList = useCallback(() => {\n    setIsSelectOpen(false);\n  }, []);\n\n  const blurHandle = (e: FocusEvent) => {\n    const isFocusOnOptionList = refs.floating.current?.contains(e.relatedTarget);\n    const isFocusOnSearchInput = !isNull(inputRef.current) && e.relatedTarget === inputRef.current;\n    const isFocusOnControl = e.relatedTarget === controlRef.current;\n\n    if (isFocusOnOptionList || isFocusOnSearchInput || isFocusOnControl) {\n      if (showSearch) {\n        returnFocusToInput();\n      } else {\n        returnFocusToWrapper();\n      }\n\n      return;\n    }\n\n    onBlur?.(e);\n    clearSearchValue();\n    closeOptionList();\n  };\n\n  const clearSelect = useCallback(\n    (e: MouseEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n\n      clearCurrentValue();\n      onClear?.();\n    },\n    [clearCurrentValue, onClear]\n  );\n\n  const keyDownHandler = (e: KeyboardEvent) => {\n    if (e.key === \"Enter\") {\n      if (isSelectOpen) {\n        const value = getCurrentSelectingValue();\n\n        if (!value) {\n          return;\n        }\n\n        if (currentValue.includes(value)) {\n          removeValue(value);\n        } else {\n          changeCurrentValue(value);\n        }\n\n        if (withAutoClear) {\n          clearSearchValue();\n        }\n      }\n\n      clickHandle();\n    }\n\n    setIsSelectOpen(true);\n\n    onKeyControl(e);\n    onInputKeyDown?.(e);\n  };\n\n  const mouseOverHandle = () => {\n    setIsHover(true);\n  };\n\n  const mouseOutHandle = () => {\n    setIsHover(false);\n  };\n\n  const focusHandle = (e: FocusEvent) => {\n    onFocus?.(e);\n\n    if (!showSearch) {\n      return;\n    }\n\n    returnFocusToInput();\n  };\n\n  const renderTagPlaceholder = (hiddenElementsCounter: number) => {\n    if (isUndefined(maxTagPlaceholder)) {\n      return <TagPlaceholder hiddenElementsCounter={hiddenElementsCounter} />;\n    }\n\n    if (!isFunction(maxTagPlaceholder)) {\n      return <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder}</span>;\n    }\n\n    const hiddenElements = currentValue.reduce((acc: Option[], value) => {\n      const isHidden = isItemHidden.get(value);\n      const option = getOptionByValue(value);\n\n      if (!isHidden || isUndefined(option)) {\n        return acc;\n      }\n\n      acc.push(option);\n\n      return acc;\n    }, []);\n\n    return (\n      <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder(hiddenElements)}</span>\n    );\n  };\n\n  const renderLabel = (values: OptionValue[], currentLabel: string[]) => {\n    const visibleLabels = getVisibleLabels(currentLabel, maxTagCount);\n\n    const label = visibleLabels.map((label, index) => {\n      const value = values[index] as OptionValue;\n\n      if (isFunction(labelRender)) {\n        return labelRender({ label, value });\n      }\n\n      if (mode === \"single\") {\n        return label;\n      }\n\n      if (isFunction(tagRender)) {\n        return tagRender(label);\n      }\n\n      const isHidden = !!isItemHidden.get(value);\n\n      return (\n        <SelectTag<OptionValue>\n          value={value}\n          label={label}\n          removeValue={removeValue}\n          maxTagTextLength={maxTagTextLength}\n          isBorderless={variant === \"borderless\"}\n          isError={status === \"error\"}\n          disabled={disabled}\n          isHidden={isHidden}\n          onTagClose={onTagClose}\n          key={value?.toString()}\n        />\n      );\n    });\n\n    const hiddenElementsCounter = isNumber(maxTagCount)\n      ? isItemHidden.size - maxTagCount\n      : Array.from(isItemHidden.values()).reduce((acc, isHidden) => (isHidden ? acc + 1 : acc), 0);\n\n    const withTagPlaceholder =\n      !isUndefined(maxTagCount) && mode === \"multiple\" && hiddenElementsCounter > 0;\n\n    if (label.length === 0) {\n      return null;\n    }\n\n    return (\n      <>\n        {label}\n        {withTagPlaceholder && renderTagPlaceholder(hiddenElementsCounter)}\n      </>\n    );\n  };\n\n  const renderSuffix = () => {\n    if (withDrawer) {\n      return (\n        <BarsOutlined\n          onClick={clickHandle}\n          css={[selectDefaultStyle.drawerIcon(theme), styles?.drawerIcon?.(theme)]}\n        />\n      );\n    }\n\n    if (showSearch && isSelectOpen) {\n      return <SearchOutlined />;\n    }\n\n    return suffixIcon;\n  };\n\n  const renderPlaceholder = () => (\n    <span css={[selectDefaultStyle.placeholder(theme), styles?.placeholder?.(theme)]}>\n      {placeholder}\n    </span>\n  );\n\n  const withClearButton = allowClear && !!filteredActiveValues.length;\n\n  const inputValue =\n    mode === \"multiple\" || isSelectOpen\n      ? (searchValue ?? searchInputValue)\n      : currentLabel[0]?.toString();\n\n  const isEmpty = filteredActiveValues.length === 0;\n  const singleModPlaceholder = currentLabel[0] ?? placeholder ?? \"\";\n  const multipleModPlaceholder = isEmpty ? placeholder : undefined;\n\n  const searchInputPlaceholder = mode === \"single\" ? singleModPlaceholder : multipleModPlaceholder;\n\n  const lettersNumber = (inputValue?.length ?? 0) + 1;\n\n  const hasIconPrefix = typeof prefix === \"object\";\n\n  const contextValue: BaseSelectContextShape<OptionValue> = {\n    currentValue: activeValues,\n    showOptionList: open ?? isSelectOpen,\n    setValue: changeHandle,\n    closeOptionList,\n    dropdownMinWidth,\n    dropdownMaxHeight,\n    dropdownPrompt,\n    loading,\n    dropdownClassName,\n    dropdownRender,\n    dropdownMatchSelectWidth,\n    referenceOffsetWidth,\n    floatingStyles,\n    setFloating: refs.setFloating,\n    floatingRef: refs.floating,\n    getPopupContainer,\n    virtual,\n    currentSelectingIndex,\n    emptyContent,\n    notFoundContent,\n    searchValue: searchValue ?? searchInputValue,\n    showSearch,\n    mode,\n    removeValue,\n    isItemHidden,\n    getCurrentSelectingValue,\n  };\n\n  return (\n    <baseSelectContext.Provider value={contextValue}>\n      <span\n        css={[selectDefaultStyle.wrapper(theme), styles?.wrapper?.(theme)]}\n        tabIndex={1}\n        onKeyDown={keyDownHandler}\n        onMouseOver={mouseOverHandle}\n        onMouseOut={mouseOutHandle}\n        onFocus={focusHandle}\n        onBlur={blurHandle}\n        autoFocus={autoFocus}\n        ref={controlRef}\n      >\n        <span\n          css={[selectDefaultStyle.body(theme), styles?.body?.(theme)]}\n          onClick={!withDrawer ? clickHandle : undefined}\n          ref={refs.setReference}\n        >\n          <span\n            css={[selectDefaultStyle.prefixAndContent(theme), styles?.prefixAndContent?.(theme)]}\n          >\n            {prefix && (\n              <span\n                css={[selectDefaultStyle.prefix(hasIconPrefix)(theme), styles?.prefix?.(theme)]}\n              >\n                {prefix}\n              </span>\n            )}\n\n            {showSearch ? (\n              <span ref={containerRef} css={selectDefaultStyle.content(theme)}>\n                {mode === \"multiple\" && renderLabel(filteredActiveValues, currentLabel)}\n                <input\n                  css={selectDefaultStyle.searchInput(theme)}\n                  value={inputValue ?? \"\"}\n                  onChange={searchHandle}\n                  placeholder={searchInputPlaceholder?.toString()}\n                  ref={inputRef}\n                  disabled={disabled}\n                  style={getSelectSearchInputWidthStyle(\n                    mode === \"multiple\",\n                    isEmpty,\n                    lettersNumber\n                  )}\n                  data-element=\"search-input\"\n                />\n              </span>\n            ) : (\n              <span\n                ref={containerRef}\n                css={[selectDefaultStyle.content(theme), styles?.content?.(theme)]}\n              >\n                {renderLabel(filteredActiveValues, currentLabel) ?? renderPlaceholder()}\n              </span>\n            )}\n          </span>\n\n          {withClearButton && (\n            <CloseCircleFilled\n              className=\"clean-button\"\n              onClick={clearSelect}\n              css={[selectDefaultStyle.cleanIcon(theme), styles?.cleanIcon?.(theme)]}\n              data-element=\"clean-button\"\n            />\n          )}\n          <span css={[selectDefaultStyle.suffixIcon(theme), styles?.suffixIcon?.(theme)]}>\n            {renderSuffix()}\n          </span>\n        </span>\n\n        <SelectOptionList<Option, OptionValue>\n          options={filteredAndSortedOptions}\n          renderDropdownItem={renderDropdownItem}\n          optionRender={optionRender}\n          virtualizerEstimateSize={virtualizerEstimateSize}\n          styles={styles?.dropdownStyle}\n        />\n      </span>\n    </baseSelectContext.Provider>\n  );\n};\n\nexport const BaseSelect = memo(BaseSelectComponent) as typeof BaseSelectComponent;\n"]} */"], "data-element": "clean-button" }),
+      /* @__PURE__ */ jsx("span", { css: [selectDefaultStyle.suffixIcon(theme), (_i = styles == null ? void 0 : styles.suffixIcon) == null ? void 0 : _i.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:BaseSelectComponent;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx"],"names":[],"mappings":"AA6gBgB","file":"/builds/frontend/libs/ui-kit/src/components/BaseSelect/BaseSelect.tsx","sourcesContent":["import {\n  type FocusEvent,\n  type KeyboardEvent,\n  memo,\n  type MouseEvent,\n  type PropsWithChildren,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport { getSelectDefaultStyle, getSelectSearchInputWidthStyle } from \"./BaseSelect.styles\";\nimport { useTheme } from \"hooks/useTheme\";\nimport { BarsOutlined, CloseCircleFilled, DownOutlined, SearchOutlined } from \"@infomaximum/icons\";\nimport { isFunction, isNull, isNumber, isUndefined } from \"lodash-es\";\nimport { autoUpdate, flip, offset, useFloating } from \"@floating-ui/react\";\nimport { convertSelectPlacement, getLabel, getVisibleLabels } from \"./BaseSelect.utils\";\nimport { useSearch } from \"./hooks/useSearch\";\nimport { useCurrentValue } from \"./hooks/useCurrentValue\";\nimport { SelectTag } from \"./components/SelectTag/SelectTag\";\nimport { useHideElements } from \"./hooks/useHideElements\";\nimport {\n  TagPlaceholder,\n  tagPlaceholderDataElement,\n} from \"./components/TagPlaceholder/TagPlaceholder\";\nimport type { BaseSelectOptionInterface, BaseSelectProps } from \"./BaseSelect.types\";\nimport { SelectOptionList } from \"./components/SelectOptionList/SelectOptionList\";\nimport { createBaseSelectContext, type BaseSelectContextShape } from \"./contexts/BaseSelectContext\";\n\nconst BaseSelectComponent = <Option extends BaseSelectOptionInterface<OptionValue>, OptionValue>({\n  options = [],\n  mode = \"single\",\n  variant = \"outlined\",\n  defaultValue,\n  defaultOpen = false,\n  defaultActiveFirstOption,\n  value,\n  open,\n  placeholder,\n  dropdownMinWidth = 120,\n  dropdownMaxHeight = 414,\n  allowClear = false,\n  autoFocus,\n  prefix,\n  suffixIcon = <DownOutlined />,\n  status = \"default\",\n  disabled = false,\n  dropdownPrompt,\n  loading = false,\n  dropdownClassName,\n  styles,\n  dropdownMatchSelectWidth = true,\n  placement = \"bottomLeft\",\n  virtual = true,\n  emptyContent = \"\",\n  showSearch = mode === \"single\" ? false : true,\n  searchValue,\n  notFoundContent = \"Not found\",\n  optionLabelProp = \"title\",\n  drawer = false,\n  autoClearSearchValue = true,\n  maxTagCount,\n  maxTagTextLength,\n  maxTagPlaceholder,\n  currentSelectingIndex,\n  getCurrentSelectingValue,\n  onKeyControl,\n  getOptionByValue,\n  virtualizerEstimateSize,\n  filterOptions,\n  filterSort,\n  valuesFilter,\n  dropdownRender,\n  optionRender,\n  labelRender,\n  onBlur,\n  onChange,\n  onClear,\n  onDropdownVisibleChange,\n  onFocus,\n  onInputKeyDown,\n  onSelect,\n  getPopupContainer = () => document.body,\n  onSearch,\n  tagRender,\n  onDeselect,\n  renderDropdownItem,\n  onTagClose,\n}: PropsWithChildren<BaseSelectProps<Option, OptionValue>>) => {\n  const theme = useTheme();\n  const baseSelectContext = createBaseSelectContext<OptionValue>();\n\n  const { filteredAndSortedOptions, searchInputValue, searchHandle, clearSearchValue } = useSearch<\n    Option,\n    OptionValue\n  >({\n    options,\n    searchValue,\n    onSearch,\n    filterSort,\n    filterOptions,\n  });\n\n  const { currentValue, changeCurrentValue, removeValue, clearCurrentValue } = useCurrentValue(\n    mode,\n    defaultValue,\n    defaultActiveFirstOption,\n    options,\n    onDeselect\n  );\n\n  const [isSelectOpen, setIsSelectOpen] = useState(defaultOpen);\n  const [isHover, setIsHover] = useState(false);\n\n  const isInitialMount = useRef(true);\n  const controlRef = useRef<HTMLSpanElement | null>(null);\n  const inputRef = useRef<HTMLInputElement | null>(null);\n\n  const referenceOffsetWidth = controlRef.current?.offsetWidth;\n\n  const { refs, floatingStyles } = useFloating<HTMLSpanElement>({\n    whileElementsMounted: autoUpdate,\n    placement: convertSelectPlacement(placement),\n    middleware: [offset(4), flip()],\n  });\n\n  const returnFocusToWrapper = useCallback(() => {\n    setTimeout(() => {\n      controlRef.current?.focus();\n    });\n  }, []);\n\n  const returnFocusToInput = useCallback(() => {\n    setTimeout(() => {\n      inputRef.current?.focus();\n    });\n  }, []);\n\n  useEffect(() => {\n    if (!isInitialMount.current) {\n      const options = currentValue.reduce((acc: Option[], value) => {\n        const option = getOptionByValue(value);\n\n        if (isUndefined(option)) {\n          return acc;\n        }\n\n        return [...acc, option];\n      }, []);\n\n      onChange?.(currentValue, options);\n    }\n  }, [currentValue, getOptionByValue, onChange]);\n\n  useEffect(() => {\n    if (isInitialMount.current) {\n      isInitialMount.current = false;\n    } else {\n      onDropdownVisibleChange?.();\n    }\n  }, [isSelectOpen, onDropdownVisibleChange]);\n\n  const activeValues = useMemo(() => {\n    return Array.isArray(value) ? value : isUndefined(value) ? currentValue : [value];\n  }, [currentValue, value]);\n\n  const selectDefaultStyle = getSelectDefaultStyle({\n    status,\n    disabled,\n    variant,\n    multiple: mode === \"multiple\",\n    isHover,\n    maxTagCount,\n    withPrefix: !!prefix,\n    isEmpty: activeValues.length === 0,\n  });\n\n  const filteredActiveValues = useMemo(() => {\n    return isFunction(valuesFilter) ? valuesFilter(activeValues) : activeValues;\n  }, [activeValues, valuesFilter]);\n\n  const { containerRef, isItemHidden } = useHideElements(\n    filteredActiveValues,\n    theme.spaceXS,\n    inputRef,\n    maxTagCount\n  );\n\n  const currentLabel = getLabel<Option, OptionValue>(\n    filteredActiveValues,\n    getOptionByValue,\n    optionLabelProp\n  );\n\n  const withDrawer = mode === \"multiple\" && drawer;\n  const withAutoClear = mode === \"single\" || autoClearSearchValue;\n\n  const clickHandle = () => {\n    if (disabled) {\n      return;\n    }\n\n    setIsSelectOpen((prev) => !prev);\n  };\n\n  const changeHandle = useCallback(\n    (value: OptionValue | OptionValue[]) => {\n      changeCurrentValue(value);\n\n      if (Array.isArray(value)) {\n        return;\n      }\n\n      const option = getOptionByValue(value);\n\n      if (withAutoClear) {\n        clearSearchValue();\n      }\n\n      if (option) {\n        onSelect?.(value, option);\n      }\n    },\n    [changeCurrentValue, clearSearchValue, getOptionByValue, onSelect, withAutoClear]\n  );\n\n  const closeOptionList = useCallback(() => {\n    setIsSelectOpen(false);\n  }, []);\n\n  const blurHandle = (e: FocusEvent) => {\n    const isFocusOnOptionList = refs.floating.current?.contains(e.relatedTarget);\n    const isFocusOnSearchInput = !isNull(inputRef.current) && e.relatedTarget === inputRef.current;\n    const isFocusOnControl = e.relatedTarget === controlRef.current;\n\n    if (isFocusOnOptionList || isFocusOnSearchInput || isFocusOnControl) {\n      if (showSearch) {\n        returnFocusToInput();\n      } else {\n        returnFocusToWrapper();\n      }\n\n      return;\n    }\n\n    onBlur?.(e);\n    clearSearchValue();\n    closeOptionList();\n  };\n\n  const clearSelect = useCallback(\n    (e: MouseEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n\n      clearCurrentValue();\n      onClear?.();\n    },\n    [clearCurrentValue, onClear]\n  );\n\n  const keyDownHandler = (e: KeyboardEvent) => {\n    if (e.key === \"Enter\") {\n      if (isSelectOpen) {\n        const value = getCurrentSelectingValue();\n\n        if (!value) {\n          return;\n        }\n\n        if (currentValue.includes(value)) {\n          removeValue(value);\n        } else {\n          changeCurrentValue(value);\n        }\n\n        if (withAutoClear) {\n          clearSearchValue();\n        }\n      }\n\n      clickHandle();\n    }\n\n    setIsSelectOpen(true);\n\n    onKeyControl(e);\n    onInputKeyDown?.(e);\n  };\n\n  const mouseOverHandle = () => {\n    setIsHover(true);\n  };\n\n  const mouseOutHandle = () => {\n    setIsHover(false);\n  };\n\n  const focusHandle = (e: FocusEvent) => {\n    onFocus?.(e);\n\n    if (!showSearch) {\n      return;\n    }\n\n    returnFocusToInput();\n  };\n\n  const renderTagPlaceholder = (hiddenElementsCounter: number) => {\n    if (isUndefined(maxTagPlaceholder)) {\n      return <TagPlaceholder hiddenElementsCounter={hiddenElementsCounter} />;\n    }\n\n    if (!isFunction(maxTagPlaceholder)) {\n      return <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder}</span>;\n    }\n\n    const hiddenElements = currentValue.reduce((acc: Option[], value) => {\n      const isHidden = isItemHidden.get(value);\n      const option = getOptionByValue(value);\n\n      if (!isHidden || isUndefined(option)) {\n        return acc;\n      }\n\n      acc.push(option);\n\n      return acc;\n    }, []);\n\n    return (\n      <span data-element={tagPlaceholderDataElement}>{maxTagPlaceholder(hiddenElements)}</span>\n    );\n  };\n\n  const renderLabel = (values: OptionValue[], currentLabel: string[]) => {\n    const visibleLabels = getVisibleLabels(currentLabel, maxTagCount);\n\n    const label = visibleLabels.map((label, index) => {\n      const value = values[index] as OptionValue;\n\n      if (isFunction(labelRender)) {\n        return labelRender({ label, value });\n      }\n\n      if (mode === \"single\") {\n        return label;\n      }\n\n      if (isFunction(tagRender)) {\n        return tagRender(label);\n      }\n\n      const isHidden = !!isItemHidden.get(value);\n\n      return (\n        <SelectTag<OptionValue>\n          value={value}\n          label={label}\n          removeValue={removeValue}\n          maxTagTextLength={maxTagTextLength}\n          isBorderless={variant === \"borderless\"}\n          isError={status === \"error\"}\n          disabled={disabled}\n          isHidden={isHidden}\n          onTagClose={onTagClose}\n          key={value?.toString()}\n        />\n      );\n    });\n\n    const hiddenElementsCounter = isNumber(maxTagCount)\n      ? isItemHidden.size - maxTagCount\n      : Array.from(isItemHidden.values()).reduce((acc, isHidden) => (isHidden ? acc + 1 : acc), 0);\n\n    const withTagPlaceholder =\n      !isUndefined(maxTagCount) && mode === \"multiple\" && hiddenElementsCounter > 0;\n\n    if (label.length === 0) {\n      return null;\n    }\n\n    return (\n      <>\n        {label}\n        {withTagPlaceholder && renderTagPlaceholder(hiddenElementsCounter)}\n      </>\n    );\n  };\n\n  const renderSuffix = () => {\n    if (withDrawer) {\n      return (\n        <BarsOutlined\n          onClick={clickHandle}\n          css={[selectDefaultStyle.drawerIcon(theme), styles?.drawerIcon?.(theme)]}\n        />\n      );\n    }\n\n    if (showSearch && isSelectOpen) {\n      return <SearchOutlined />;\n    }\n\n    return suffixIcon;\n  };\n\n  const renderPlaceholder = () => (\n    <span css={[selectDefaultStyle.placeholder(theme), styles?.placeholder?.(theme)]}>\n      {placeholder}\n    </span>\n  );\n\n  const withClearButton = allowClear && !!filteredActiveValues.length;\n\n  const inputValue =\n    mode === \"multiple\" || isSelectOpen\n      ? (searchValue ?? searchInputValue)\n      : currentLabel[0]?.toString();\n\n  const isEmpty = filteredActiveValues.length === 0;\n  const singleModPlaceholder = currentLabel[0] ?? placeholder ?? \"\";\n  const multipleModPlaceholder = isEmpty ? placeholder : undefined;\n\n  const searchInputPlaceholder = mode === \"single\" ? singleModPlaceholder : multipleModPlaceholder;\n\n  const lettersNumber = (inputValue?.length ?? 0) + 1;\n\n  const hasIconPrefix = typeof prefix === \"object\";\n\n  const contextValue: BaseSelectContextShape<OptionValue> = {\n    currentValue: activeValues,\n    showOptionList: open ?? isSelectOpen,\n    setValue: changeHandle,\n    closeOptionList,\n    dropdownMinWidth,\n    dropdownMaxHeight,\n    dropdownPrompt,\n    loading,\n    dropdownClassName,\n    dropdownRender,\n    dropdownMatchSelectWidth,\n    referenceOffsetWidth,\n    floatingStyles,\n    setFloating: refs.setFloating,\n    floatingRef: refs.floating,\n    getPopupContainer,\n    virtual,\n    currentSelectingIndex,\n    emptyContent,\n    notFoundContent,\n    searchValue: searchValue ?? searchInputValue,\n    showSearch,\n    mode,\n    removeValue,\n    isItemHidden,\n    getCurrentSelectingValue,\n  };\n\n  return (\n    <baseSelectContext.Provider value={contextValue}>\n      <span\n        css={[selectDefaultStyle.wrapper(theme), styles?.wrapper?.(theme)]}\n        tabIndex={1}\n        onKeyDown={keyDownHandler}\n        onMouseOver={mouseOverHandle}\n        onMouseOut={mouseOutHandle}\n        onFocus={focusHandle}\n        onBlur={blurHandle}\n        autoFocus={autoFocus}\n        ref={controlRef}\n      >\n        <span\n          css={[selectDefaultStyle.body(theme), styles?.body?.(theme)]}\n          onClick={!withDrawer ? clickHandle : undefined}\n          ref={refs.setReference}\n        >\n          <span\n            css={[selectDefaultStyle.prefixAndContent(theme), styles?.prefixAndContent?.(theme)]}\n          >\n            {prefix && (\n              <span\n                css={[selectDefaultStyle.prefix(hasIconPrefix)(theme), styles?.prefix?.(theme)]}\n              >\n                {prefix}\n              </span>\n            )}\n\n            {showSearch ? (\n              <span ref={containerRef} css={selectDefaultStyle.content(theme)}>\n                {mode === \"multiple\" && renderLabel(filteredActiveValues, currentLabel)}\n                <input\n                  css={selectDefaultStyle.searchInput(theme)}\n                  value={inputValue ?? \"\"}\n                  onChange={searchHandle}\n                  placeholder={searchInputPlaceholder?.toString()}\n                  ref={inputRef}\n                  disabled={disabled}\n                  style={getSelectSearchInputWidthStyle(\n                    mode === \"multiple\",\n                    isEmpty,\n                    lettersNumber\n                  )}\n                  data-element=\"search-input\"\n                />\n              </span>\n            ) : (\n              <span\n                ref={containerRef}\n                css={[selectDefaultStyle.content(theme), styles?.content?.(theme)]}\n              >\n                {renderLabel(filteredActiveValues, currentLabel) ?? renderPlaceholder()}\n              </span>\n            )}\n          </span>\n\n          {withClearButton && (\n            <CloseCircleFilled\n              className=\"clean-button\"\n              onClick={clearSelect}\n              css={[selectDefaultStyle.cleanIcon(theme), styles?.cleanIcon?.(theme)]}\n              data-element=\"clean-button\"\n            />\n          )}\n          <span css={[selectDefaultStyle.suffixIcon(theme), styles?.suffixIcon?.(theme)]}>\n            {renderSuffix()}\n          </span>\n        </span>\n\n        <SelectOptionList<Option, OptionValue>\n          options={filteredAndSortedOptions}\n          renderDropdownItem={renderDropdownItem}\n          optionRender={optionRender}\n          virtualizerEstimateSize={virtualizerEstimateSize}\n          styles={styles?.dropdownStyle}\n        />\n      </span>\n    </baseSelectContext.Provider>\n  );\n};\n\nexport const BaseSelect = memo(BaseSelectComponent) as typeof BaseSelectComponent;\n"]} */"], children: renderSuffix() })
+    ] }),
+    /* @__PURE__ */ jsx(SelectOptionList, { options: filteredAndSortedOptions, renderDropdownItem, optionRender, virtualizerEstimateSize, styles: styles == null ? void 0 : styles.dropdownStyle })
+  ] }) });
+};
+const BaseSelect = memo(BaseSelectComponent);
+export {
+  BaseSelect
+};