import { objectWithoutProperties as _objectWithoutProperties, slicedToArray as _slicedToArray, extends as _extends, typeof as _typeof } from '../../../_virtual/_rollupPluginBabelHelpers.js';
import React__default, { forwardRef, useMemo, useState, useRef, useReducer, useLayoutEffect } from 'react';
import { classes } from './Combobox.tokens.js';
import { FloatingPopover } from './FloatingPopover.js';
import { getItemByFocused, useKeyNavigation } from './hooks/useKeyboardNavigation.js';
import { getTreeMaps, getPathMap } from './hooks/getPathMaps.js';
import { IconArrowWrapper, StyledArrow, StyledLeftHelper, ListWrapper, Ul, StyledEmptyState, base } from './Combobox.styles.js';
import { base as base$1 } from './variations/_view/base.js';
import { base as base$2 } from './variations/_size/base.js';
import { SelectNative } from './ui/SelectNative/SelectNative.js';
import { Context } from './Combobox.context.js';
import { initialItemsTransform } from './utils/initialItemsTransform.js';
import { getTextValue } from './utils/getTextValue.js';
import { useForkRef } from '../../../hooks/useForkRef.js';
import { safeUseId } from '../../../utils/react.js';
import { filterItems, defaultFilter } from './utils/filterItems.js';
import { pathReducer } from './reducers/pathReducer.js';
import { focusedPathReducer } from './reducers/focusedPathReducer.js';
import { treePathReducer } from './reducers/treePathReducer.js';
import { useOutsideClick } from '../../../hooks/useOutsideClick.js';
import { isEmpty } from '../../../utils/isEmpty.js';
import { updateDescendants } from './utils/updateDescendants.js';
import { updateAncestors } from './utils/updateAncestors.js';
import { updateSingleAncestors } from './utils/updateSingleAncestors.js';
import { useDidMountLayoutEffect } from '../../../hooks/useDidMountLayoutEffect.js';
import { StyledTextField } from './ui/Target/Target.styles.js';
import { sizeToIconSize } from './utils/sizeToIconSize.js';
import { getItemId } from './utils/getItemId.js';
import { TreeList } from './ui/TreeList/TreeList.js';
import { SelectAll } from './ui/SelectAll/SelectAll.js';
import { VirtualList } from './ui/VirtualList/VirtualList.js';
import { Inner } from './ui/Inner/Inner.js';

var _excluded = ["name", "multiple", "value", "onChange", "defaultValue", "isTargetAmount", "targetAmount", "items", "treeView", "arrowPlacement", "placement", "label", "placeholder", "helperText", "contentLeft", "contentRight", "textBefore", "textAfter", "variant", "listOverflow", "listHeight", "listMaxHeight", "listWidth", "portal", "renderItem", "renderSelectionIcon", "view", "size", "labelPlacement", "keepPlaceholder", "readOnly", "disabled", "alwaysOpened", "filter", "closeAfterSelect", "renderValue", "zIndex", "beforeList", "afterList", "virtual", "hintView", "hintSize", "emptyStateDescription", "onChangeValue", "filterValue", "onScroll", "onToggle", "mode", "chipClickArea", "shift", "flip", "singleLine", "_offset"];

/**
 * Поле ввода с выпадающим списком и возможностью фильтрации и выбора элементов.
 */
var comboboxRoot = function comboboxRoot(Root) {
  return /*#__PURE__*/forwardRef(function (props, ref) {
    var _getItemByFocused, _StyledLeftHelper;
    var name = props.name,
      multiple = props.multiple,
      outerValue = props.value,
      defaultValue = props.defaultValue,
      isTargetAmount = props.isTargetAmount,
      targetAmount = props.targetAmount,
      items = props.items,
      _props$treeView = props.treeView,
      treeView = _props$treeView === void 0 ? false : _props$treeView,
      _props$arrowPlacement = props.arrowPlacement,
      arrowPlacement = _props$arrowPlacement === void 0 ? 'left' : _props$arrowPlacement,
      _props$placement = props.placement,
      placement = _props$placement === void 0 ? 'bottom-start' : _props$placement,
      label = props.label,
      placeholder = props.placeholder,
      helperText = props.helperText,
      contentLeft = props.contentLeft,
      contentRight = props.contentRight,
      textBefore = props.textBefore,
      textAfter = props.textAfter,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'normal' : _props$variant,
      listHeight = props.listHeight,
      listMaxHeight = props.listMaxHeight,
      listWidth = props.listWidth,
      portal = props.portal,
      renderItem = props.renderItem,
      renderSelectionIcon = props.renderSelectionIcon,
      view = props.view,
      size = props.size,
      labelPlacement = props.labelPlacement,
      keepPlaceholder = props.keepPlaceholder,
      _props$readOnly = props.readOnly,
      readOnly = _props$readOnly === void 0 ? false : _props$readOnly,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$alwaysOpened = props.alwaysOpened,
      alwaysOpened = _props$alwaysOpened === void 0 ? false : _props$alwaysOpened,
      filter = props.filter,
      outerCloseAfterSelect = props.closeAfterSelect,
      renderValue = props.renderValue,
      zIndex = props.zIndex,
      beforeList = props.beforeList,
      afterList = props.afterList,
      _props$virtual = props.virtual,
      virtual = _props$virtual === void 0 ? false : _props$virtual,
      hintView = props.hintView,
      hintSize = props.hintSize,
      emptyStateDescription = props.emptyStateDescription,
      onChangeValue = props.onChangeValue,
      filterValue = props.filterValue,
      onScroll = props.onScroll,
      onToggle = props.onToggle,
      _props$mode = props.mode,
      mode = _props$mode === void 0 ? 'default' : _props$mode,
      _props$chipClickArea = props.chipClickArea,
      chipClickArea = _props$chipClickArea === void 0 ? 'full' : _props$chipClickArea,
      shift = props.shift,
      flip = props.flip,
      singleLine = props.singleLine,
      _offset = props._offset,
      rest = _objectWithoutProperties(props, _excluded);
    var transformedItems = useMemo(function () {
      return initialItemsTransform(items || []);
    }, [items]);

    // Создаем структуры для быстрой работы с деревом
    var _useMemo = useMemo(function () {
        return getTreeMaps(transformedItems);
      }, [items]),
      _useMemo2 = _slicedToArray(_useMemo, 3),
      valueToCheckedMap = _useMemo2[0],
      valueToItemMap = _useMemo2[1],
      valueToPathMap = _useMemo2[2];

    // Состояние поля поиска в target
    var _useState = useState(getTextValue(multiple, outerValue, valueToItemMap, renderValue)),
      _useState2 = _slicedToArray(_useState, 2),
      textValue = _useState2[0],
      setTextValueState = _useState2[1];

    // Внутреннее состояние выбранных элементов
    var _useState3 = useState(multiple ? [] : ''),
      _useState4 = _slicedToArray(_useState3, 2),
      internalValue = _useState4[0],
      setInternalValue = _useState4[1];
    var value = outerValue !== null && outerValue !== undefined ? outerValue : internalValue;
    var rootRef = useRef(null);
    var inputRef = useRef(null);
    var floatingPopoverRef = useRef(null);
    var inputForkRef = useForkRef(inputRef, ref);
    var listWrapperRef = useRef(null);
    var treeId = safeUseId();
    var filterCb = filter || defaultFilter;
    var filteredItems = useMemo(function () {
      return filterItems(transformedItems, textValue, getTextValue(multiple, value, valueToItemMap, renderValue), filter);
    }, [transformedItems, textValue, filter, value]);
    var _useMemo3 = useMemo(function () {
        return getPathMap(filteredItems);
      }, [filteredItems, textValue]),
      _useMemo4 = _slicedToArray(_useMemo3, 2),
      pathMap = _useMemo4[0],
      focusedToValueMap = _useMemo4[1];
    var initialPath = alwaysOpened ? ['root'] : [];

    // Состояния дерева элементов
    var _useReducer = useReducer(pathReducer, initialPath),
      _useReducer2 = _slicedToArray(_useReducer, 2),
      path = _useReducer2[0],
      dispatchPath = _useReducer2[1];
    var _useReducer3 = useReducer(focusedPathReducer, []),
      _useReducer4 = _slicedToArray(_useReducer3, 2),
      focusedPath = _useReducer4[0],
      dispatchFocusedPath = _useReducer4[1];
    var _useState5 = useState(valueToCheckedMap),
      _useState6 = _slicedToArray(_useState5, 2),
      checked = _useState6[0],
      setChecked = _useState6[1];
    var _useReducer5 = useReducer(treePathReducer, {}),
      _useReducer6 = _slicedToArray(_useReducer5, 2),
      treePath = _useReducer6[0],
      dispatchTreePath = _useReducer6[1];
    var isCurrentListOpen = Boolean(path[0]);
    var activeDescendantItemValue = ((_getItemByFocused = getItemByFocused(focusedPath, focusedToValueMap)) === null || _getItemByFocused === void 0 ? void 0 : _getItemByFocused.value) || '';
    var withArrowInverse = isCurrentListOpen ? classes.arrowInverse : undefined;
    var closeAfterSelect = outerCloseAfterSelect !== null && outerCloseAfterSelect !== void 0 ? outerCloseAfterSelect : !multiple;
    var setTextValue = function setTextValue(newTextValue) {
      /* Если значение поля ввода не изменилось, то выходим из функции */
      if (newTextValue === textValue) {
        return;
      }
      setTextValueState(newTextValue);
      if (onChangeValue) {
        onChangeValue(newTextValue);
      }
    };

    /* Логика работы при клике за пределами выпадающего списка */
    useOutsideClick(function () {
      if (!isCurrentListOpen || alwaysOpened) {
        return;
      }
      handleListToggle(false);
    }, [floatingPopoverRef, listWrapperRef]);

    // Эта функция срабатывает при изменении Combobox и
    // при изменении нативного Select для формы (срабатывает только после изменения internalValue и рендера).
    var onChange = function onChange(newValue, item) {
      // Условие для отправки изменений наружу
      if (props.onChange) {
        // Условие для отправки, если комбобокс используется без формы.
        if (!props.name && (typeof newValue === 'string' || Array.isArray(newValue))) {
          props.onChange(newValue, item || null);
        }

        // Условие для отправки, если комбобокс используется с формой.
        if (props.name && _typeof(newValue) === 'object' && !Array.isArray(newValue)) {
          props.onChange(newValue);
        }
      }

      // Условие для изменения внутреннего значения (только если newValue строка или массив строк).
      if (typeof newValue === 'string' || Array.isArray(newValue)) {
        setInternalValue(newValue);
      }
    };
    var handleClickArrow = function handleClickArrow(e) {
      handleListToggle(!isCurrentListOpen);

      // При клике на иконку закрытия фокус не должен становиться в инпут.
      e.stopPropagation();
    };

    // Обработчик изменения значения в инпуте
    var handleTextValueChange = function handleTextValueChange(e) {
      if (!filterValue || filterValue(e.target.value)) {
        setTextValue(e.target.value);
      }
      dispatchPath({
        type: 'opened_first_level'
      });
      dispatchFocusedPath({
        type: 'reset'
      });
    };

    // Обработчик чипов
    var handleChipClick = function handleChipClick(chip) {
      if (!Array.isArray(value)) return;
      if (isTargetAmount) {
        // При закрытии чипа в режиме isTargetAmount в value оставляем только disabled-элементы
        onChange(value.filter(function (val) {
          var _valueToItemMap$get;
          return valueToItemMap === null || valueToItemMap === void 0 || (_valueToItemMap$get = valueToItemMap.get(val)) === null || _valueToItemMap$get === void 0 ? void 0 : _valueToItemMap$get.disabled;
        }), null);
      } else {
        onChange(value.filter(function (val) {
          return val !== chip.value;
        }), valueToItemMap.get(chip.value) || {
          value: chip.value,
          label: chip.label
        });
      }
    };

    // Обработчик открытия/закрытия выпадающего списка
    var handleListToggle = function handleListToggle(opened) {
      if (disabled || readOnly) {
        return;
      }
      if (opened) {
        dispatchPath({
          type: 'opened_first_level'
        });
      } else {
        var _rootRef$current;
        dispatchFocusedPath({
          type: 'reset'
        });
        dispatchPath({
          type: 'reset'
        });
        dispatchTreePath({
          type: 'reset'
        });

        // Возвращаем актуальное значение поля ввода после закрытия выпадающего списка.
        setTextValue(getTextValue(multiple, value, valueToItemMap, renderValue));

        // Скроллим чипы к левому краю при закрытии компонента
        var el = rootRef === null || rootRef === void 0 || (_rootRef$current = rootRef.current) === null || _rootRef$current === void 0 ? void 0 : _rootRef$current.querySelector('.input-scrollable-wrapper');
        if (multiple && value.length > 0 && el) {
          el.scrollLeft = 0;
        }
      }
      if (onToggle) {
        onToggle(opened);
      }
    };

    // Обработчик выбора чекбоксов (только при multiple)
    var handleCheckboxChange = function handleCheckboxChange(item) {
      if (!multiple) {
        return;
      }
      var checkedCopy = new Map(checked);
      switch (checkedCopy.get(item.value)) {
        // Если чекбокс в состоянии indeterminate
        case 'indeterminate':
          {
            updateDescendants(item, checkedCopy, true, valueToItemMap);
            break;
          }
        // Если чекбокс в состоянии checked
        case true:
          {
            updateDescendants(item, checkedCopy, false, valueToItemMap);
            checkedCopy.set(item.value, false);
            break;
          }
        // Если чекбокс в состоянии unchecked
        case false:
          {
            updateDescendants(item, checkedCopy, true, valueToItemMap);
            checkedCopy.set(item.value, true);
            break;
          }
      }
      var newValues = [];
      valueToItemMap.forEach(function (item, key) {
        if (checkedCopy.get(key)) {
          newValues.push(item.value);
        }
      });

      // Оставляем values, которых нет в items.
      if (Array.isArray(value)) {
        value.forEach(function (val) {
          if (!valueToItemMap.has(val)) {
            newValues.push(val);
          }
        });
      }
      if (!alwaysOpened && closeAfterSelect) {
        dispatchPath({
          type: 'reset'
        });
        dispatchFocusedPath({
          type: 'reset'
        });
        dispatchTreePath({
          type: 'reset'
        });
      }
      if (onChange) {
        onChange(newValues, item);
      }
    };

    // Обработчик клика по айтему выпадающего списка
    var handleItemClick = function handleItemClick(item, e) {
      if (!isEmpty(item === null || item === void 0 ? void 0 : item.items)) {
        return;
      }
      if (multiple) {
        handleCheckboxChange(item);
        return;
      }
      if (e) {
        e.stopPropagation();
      }
      var isCurrentChecked = checked.get(item.value);
      if (!alwaysOpened && closeAfterSelect) {
        dispatchPath({
          type: 'reset'
        });
        dispatchFocusedPath({
          type: 'reset'
        });
        dispatchTreePath({
          type: 'reset'
        });
      }

      // Закрываем список, если элемент уже выбран.
      if (mode === 'radio' && isCurrentChecked) {
        return;
      }
      if (onChange) {
        onChange(isCurrentChecked ? '' : item.value, item);
      }
    };

    // Обработчик клика на таргет
    var handleTargetClick = function handleTargetClick() {
      if (!isCurrentListOpen) {
        handleListToggle(true);
      }
    };
    var getChips = function getChips() {
      if (multiple && Array.isArray(value)) {
        if (value.length === 0) return [];
        if (isTargetAmount) {
          return [{
            value: '_removeAll',
            label: "\u0412\u044B\u0431\u0440\u0430\u043D\u043E ".concat(targetAmount || value.length),
            disabled: value.every(function (val) {
              var _valueToItemMap$get2;
              return valueToItemMap === null || valueToItemMap === void 0 || (_valueToItemMap$get2 = valueToItemMap.get(val)) === null || _valueToItemMap$get2 === void 0 ? void 0 : _valueToItemMap$get2.disabled;
            })
          }];
        }
        return value.map(function (value) {
          var _valueToItemMap$get3, _valueToItemMap$get4;
          var currentLabel = renderValue ? renderValue(valueToItemMap.get(value) || {
            value: value,
            label: value
          }) : ((_valueToItemMap$get3 = valueToItemMap.get(value)) === null || _valueToItemMap$get3 === void 0 ? void 0 : _valueToItemMap$get3.label) || value.toString();
          return {
            value: value,
            label: currentLabel,
            disabled: ((_valueToItemMap$get4 = valueToItemMap.get(value)) === null || _valueToItemMap$get4 === void 0 ? void 0 : _valueToItemMap$get4.disabled) || false
          };
        });
      }
      return [];
    };
    var handlePressDown = function handlePressDown(item, e) {
      if (isEmpty(item.items)) {
        handleItemClick(item, e);
      } else if (multiple) {
        handleCheckboxChange(item);
      }
    };
    var helperTextStopPropagation = function helperTextStopPropagation(event) {
      event.stopPropagation();
    };
    var _useKeyNavigation = useKeyNavigation({
        focusedPath: focusedPath,
        dispatchFocusedPath: dispatchFocusedPath,
        path: path,
        dispatchPath: dispatchPath,
        pathMap: pathMap,
        focusedToValueMap: focusedToValueMap,
        handleListToggle: handleListToggle,
        handlePressDown: handlePressDown,
        setTextValue: setTextValue,
        multiple: multiple,
        value: value,
        textValue: textValue,
        valueToItemMap: valueToItemMap,
        treePath: treePath,
        dispatchTreePath: dispatchTreePath,
        treeView: treeView,
        valueToPathMap: valueToPathMap,
        items: filteredItems
      }),
      onKeyDown = _useKeyNavigation.onKeyDown;

    // В данном эффекте мы следим за изменениями value снаружи и вносим коррективы в дерево чекбоксов.
    // Пример: когда юзер очистил value извне, тогда нужно пройтись по элементам и выключить все чекбоксы.
    useLayoutEffect(function () {
      var checkedCopy = new Map(valueToCheckedMap);
      checkedCopy.forEach(function (_, key) {
        checkedCopy.set(key, false);
      });
      if (!isEmpty(value)) {
        if (Array.isArray(value)) {
          value.forEach(function (val) {
            // Только если value находится в items, т.к. value может и не существовать в items.
            if (valueToItemMap.has(val)) {
              checkedCopy.set(val, true);
              updateDescendants(valueToItemMap.get(val), checkedCopy, true);
              updateAncestors(valueToItemMap.get(val), checkedCopy);
            }
          });
        } else {
          // Только если value находится в items, т.к. value может и не существовать в items.
          // eslint-disable-next-line no-lonely-if
          if (valueToItemMap.has(value)) {
            checkedCopy.set(value, 'done');
            updateSingleAncestors(valueToItemMap.get(value), checkedCopy, 'dot');
          }
        }
      }
      setChecked(checkedCopy);

      // В deps мы кладем именно outerValue и internalValue, а не просто value.
      // Т.к. вначале нужно отфильтровать и провалидировать outerValue и результат положить в переменную.
      // А переменную, содержащую сложные типы данных, нельзя помещать в deps.
    }, [outerValue, internalValue, items]);

    // Эффект для исключительных случаев, когда нужно обновить значение textValue при изменении items,
    // но только если значение textValue совпадает с value в item.
    useLayoutEffect(function () {
      var _valueToItemMap$get5;
      if (!multiple && value && ((_valueToItemMap$get5 = valueToItemMap.get(value)) === null || _valueToItemMap$get5 === void 0 ? void 0 : _valueToItemMap$get5.value) === textValue) {
        var _valueToItemMap$get6;
        setTextValue(((_valueToItemMap$get6 = valueToItemMap.get(value)) === null || _valueToItemMap$get6 === void 0 ? void 0 : _valueToItemMap$get6.label) || value.toString());
      }
    }, [items]);

    // При изменении value нужно возвращать значение в инпуте к исходному.
    useDidMountLayoutEffect(function () {
      setTextValue(getTextValue(multiple, value, valueToItemMap, renderValue));
    }, [outerValue, internalValue]);
    useLayoutEffect(function () {
      if (defaultValue) {
        setInternalValue(defaultValue);
      }
    }, [defaultValue]);

    // Эффект для раскрытия дерева при поиске.
    useLayoutEffect(function () {
      if (treeView) {
        // Если поле ввода стало пустым или если пользователь выбирает элемент,
        // то скрываем все узлы дерева и выходим из эффекта.
        if (textValue === '' || textValue === getTextValue(multiple, value, valueToItemMap, renderValue)) {
          dispatchTreePath({
            type: 'reset'
          });
          return;
        }

        // Иначе раскрываем все узлы, когда пользователь начинает вводить текст в поле ввода.
        dispatchTreePath({
          type: 'expand_by_key',
          value: {
            filteredItems: filteredItems,
            filterCb: filterCb,
            textValue: textValue
          }
        });
      }
    }, [textValue]);
    return /*#__PURE__*/React__default.createElement(Root, {
      size: size,
      view: view,
      labelPlacement: labelPlacement,
      disabled: disabled,
      readOnly: readOnly,
      name: name,
      hintView: hintView,
      hintSize: hintSize,
      ref: rootRef
    }, name && /*#__PURE__*/React__default.createElement(SelectNative, {
      items: valueToItemMap,
      name: name,
      value: internalValue,
      multiple: multiple,
      onChange: onChange,
      onSetValue: setInternalValue,
      ref: ref
    }), /*#__PURE__*/React__default.createElement("div", null, /*#__PURE__*/React__default.createElement(Context.Provider, {
      value: {
        focusedPath: focusedPath,
        checked: checked,
        multiple: multiple,
        size: size,
        handleCheckboxChange: handleCheckboxChange,
        handleItemClick: handleItemClick,
        variant: variant,
        renderItem: renderItem,
        renderSelectionIcon: renderSelectionIcon,
        treeId: treeId,
        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
        // @ts-ignore
        // eslint-disable-next-line no-underscore-dangle
        _checkboxAppearance: rest._checkboxAppearance,
        treePath: treePath,
        dispatchTreePath: dispatchTreePath,
        arrowPlacement: arrowPlacement,
        valueToPathMap: valueToPathMap,
        singleLine: singleLine
      }
    }, /*#__PURE__*/React__default.createElement(FloatingPopover, {
      ref: floatingPopoverRef,
      opened: isCurrentListOpen,
      placement: placement,
      portal: portal,
      listWidth: listWidth,
      offset: _offset,
      target: function target(referenceRef) {
        return /*#__PURE__*/React__default.createElement("div", {
          onClick: handleTargetClick
        }, /*#__PURE__*/React__default.createElement(StyledTextField, _extends({
          ref: name ? inputRef : inputForkRef,
          inputWrapperRef: referenceRef,
          value: textValue,
          onChange: handleTextValueChange,
          size: size,
          view: view,
          disabled: disabled,
          readOnly: readOnly,
          label: label,
          placeholder: placeholder,
          contentLeft: contentLeft,
          contentRight: contentRight || contentRight !== undefined ? contentRight : /*#__PURE__*/React__default.createElement(IconArrowWrapper, {
            disabled: disabled,
            readOnly: readOnly,
            onClick: handleClickArrow,
            className: classes.comboboxTargetArrow
          }, /*#__PURE__*/React__default.createElement(StyledArrow, {
            color: "inherit",
            size: sizeToIconSize(size),
            className: withArrowInverse
          })),
          textBefore: textBefore,
          textAfter: textAfter,
          onKeyDown: onKeyDown,
          leftHelper: helperText && (_StyledLeftHelper || (_StyledLeftHelper = /*#__PURE__*/React__default.createElement(StyledLeftHelper, {
            onClick: helperTextStopPropagation
          }, helperText))),
          role: "combobox",
          "aria-autocomplete": "list",
          "aria-controls": "".concat(treeId, "_tree_level_1"),
          "aria-expanded": isCurrentListOpen,
          "aria-activedescendant": activeDescendantItemValue ? getItemId(treeId, activeDescendantItemValue) : '',
          labelPlacement: labelPlacement,
          keepPlaceholder: keepPlaceholder
        }, multiple ? {
          enumerationType: 'chip',
          _chipClickArea: chipClickArea,
          _chips: getChips(),
          _onChipCloseClick: handleChipClick
        } : {
          enumerationType: 'plain'
        }, rest, {
          _onEnterDisabled: true // Пропс для отключения обработчика Enter внутри Textfield
        })));
      },
      zIndex: zIndex,
      isInner: false,
      shift: shift,
      flip: flip
    }, /*#__PURE__*/React__default.createElement(Root, {
      size: size,
      view: view,
      labelPlacement: labelPlacement,
      disabled: disabled,
      readOnly: readOnly,
      name: name
    }, treeView ? /*#__PURE__*/React__default.createElement(TreeList, {
      items: filteredItems,
      listMaxHeight: listMaxHeight || listHeight,
      onScroll: virtual ? undefined : onScroll,
      virtual: virtual,
      beforeList: beforeList,
      afterList: afterList,
      emptyStateDescription: emptyStateDescription
    }) : /*#__PURE__*/React__default.createElement(ListWrapper, {
      ref: listWrapperRef,
      listWidth: listWidth
    }, /*#__PURE__*/React__default.createElement(Ul, {
      role: "tree",
      id: "".concat(treeId, "_tree_level_1"),
      "aria-multiselectable": Boolean(multiple),
      listMaxHeight: listMaxHeight || listHeight,
      virtual: virtual,
      onScroll: virtual ? undefined : onScroll
    }, beforeList, props.multiple && props.selectAllOptions &&
    /*#__PURE__*/
    // TODO: #2004
    React__default.createElement(SelectAll, {
      selectAllOptions: props.selectAllOptions,
      variant: variant
    }), isEmpty(filteredItems) ? /*#__PURE__*/React__default.createElement(StyledEmptyState, {
      className: classes.emptyStateWrapper,
      description: emptyStateDescription || 'Ничего не найдено'
    }) : /*#__PURE__*/React__default.createElement(React__default.Fragment, null, virtual ? /*#__PURE__*/React__default.createElement(VirtualList, {
      items: filteredItems,
      listMaxHeight: listMaxHeight || listHeight,
      onScroll: onScroll
    }) : filteredItems.map(function (item, index) {
      return /*#__PURE__*/React__default.createElement(Inner, {
        key: "".concat(index, "/0"),
        item: item,
        currentLevel: 0,
        path: path,
        dispatchPath: dispatchPath,
        index: index,
        listWidth: listWidth,
        portal: listWrapperRef,
        shift: shift,
        flip: flip
      });
    })), afterList)))))));
  });
};
var comboboxConfig = {
  name: 'Select',
  tag: 'div',
  layout: comboboxRoot,
  base: base,
  variations: {
    view: {
      css: base$1
    },
    size: {
      css: base$2
    },
    readOnly: {
      css: base$2
    }
  },
  defaults: {
    view: 'default',
    size: 'm',
    labelPlacement: 'outer'
  }
};

export { comboboxConfig, comboboxRoot };
//# sourceMappingURL=Combobox.js.map
