@salutejs/plasma-new-hope 0.134.0-canary.1406.10628421547.0 → 0.134.1-canary.1374.10632027763.0

package/styled-components/es/components/Combobox/Combobox.js

@@ -0,0 +1,255 @@
+var _excluded = ["name", "form", "readOnly", "disabled", "label", "placeholder", "id", "children", "role", "view", "size", "frame", "usePortal", "negativeResultContent", "enumerationType", "opened", "placement", "onToggle", "onKeyDown", "filterFunction"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { Children, forwardRef, useEffect, useRef, useState } from 'react';
+import { safeUseId, useForkRef } from '@salutejs/plasma-core';
+import { cx, getPlacements } from '../../utils';
+import { useDidMountEffect, useForceUpdate } from '../../hooks';
+import { getChildren, getNewSelected, getValues } from './utils';
+import { useKeyNavigation } from './hooks';
+import { base as viewCSS } from './variations/_view/base';
+import { base as sizeCSS } from './variations/_size/base';
+import { ComboboxTarget } from './ui';
+import { ComboboxItemNotFound, StyledPopover, StyledRoot, StyledCombobox, StyledNativeSelect } from './Combobox.styles';
+/**
+ * Выпадающий список без внешнего контроля видимости.
+ */
+export var comboboxRoot = function comboboxRoot(Root) {
+  return /*#__PURE__*/forwardRef(function (_ref, outerRootRef) {
+    var _targetRef$current;
+    var name = _ref.name,
+      form = _ref.form,
+      readOnly = _ref.readOnly,
+      disabled = _ref.disabled,
+      label = _ref.label,
+      placeholder = _ref.placeholder,
+      id = _ref.id,
+      children = _ref.children,
+      role = _ref.role,
+      view = _ref.view,
+      size = _ref.size,
+      frame = _ref.frame,
+      usePortal = _ref.usePortal,
+      _ref$negativeResultCo = _ref.negativeResultContent,
+      negativeResultContent = _ref$negativeResultCo === void 0 ? 'Элементы не найдены' : _ref$negativeResultCo,
+      _ref$enumerationType = _ref.enumerationType,
+      enumerationType = _ref$enumerationType === void 0 ? 'comma' : _ref$enumerationType,
+      _ref$opened = _ref.opened,
+      opened = _ref$opened === void 0 ? false : _ref$opened,
+      _ref$placement = _ref.placement,
+      placement = _ref$placement === void 0 ? 'bottom' : _ref$placement,
+      onToggle = _ref.onToggle,
+      onKeyDown = _ref.onKeyDown,
+      filterFunction = _ref.filterFunction,
+      rest = _objectWithoutProperties(_ref, _excluded);
+    var forceUpdate = useForceUpdate();
+    var uniqId = safeUseId();
+    var innerId = id || uniqId;
+    var _rest$valueType = rest.valueType,
+      valueType = _rest$valueType === void 0 ? 'single' : _rest$valueType,
+      value = rest.value;
+    var offset = [0, 4];
+    var _useState = useState(null),
+      _useState2 = _slicedToArray(_useState, 2),
+      ref = _useState2[0],
+      setRef = _useState2[1];
+    var targetRef = useRef(null);
+    var chipsRefs = useRef([]);
+    var comboboxRef = useRef(null);
+    var itemsRefs = useRef([]);
+    var inputRef = useRef(null);
+    var handleRef = useForkRef(targetRef, outerRootRef);
+    var controlledRefs = {
+      targetRef: targetRef,
+      chipsRefs: chipsRefs,
+      selectRef: comboboxRef,
+      itemsRefs: itemsRefs,
+      inputRef: inputRef
+    };
+    var _useState3 = useState(opened),
+      _useState4 = _slicedToArray(_useState3, 2),
+      isVisible = _useState4[0],
+      setIsVisible = _useState4[1];
+    var _useState5 = useState(''),
+      _useState6 = _slicedToArray(_useState5, 2),
+      search = _useState6[0],
+      setSearch = _useState6[1];
+    var _useState7 = useState(search),
+      _useState8 = _slicedToArray(_useState7, 2),
+      filterValue = _useState8[0],
+      setFilterValue = _useState8[1];
+
+    // INFO: нужно высчитывать для корректной работы портала
+    var dynamicTargetWidth = (_targetRef$current = targetRef.current) === null || _targetRef$current === void 0 ? void 0 : _targetRef$current.offsetWidth;
+
+    // INFO: Из-за того, что классы передаются через ref,
+    // состояние пропсов после изменения view, size
+    // всегда предыдущее, поэтому нужно делать форс-ререндер
+    useDidMountEffect(function () {
+      forceUpdate();
+    }, [view, size]);
+    useEffect(function () {
+      if (disabled || readOnly) {
+        return;
+      }
+      setIsVisible(opened);
+    }, [opened, disabled, readOnly]);
+    useEffect(function () {
+      // INFO: Для кейсов, когда значение выбрано и нужно вывести весь список
+      if (opened) {
+        setFilterValue('');
+      }
+    }, []);
+    var onInnerToggle = function onInnerToggle(openValue, event) {
+      if (disabled || readOnly) {
+        return;
+      }
+
+      // INFO: Для кейсов, когда значение выбрано и нужно вывести весь список
+      if (!isVisible) {
+        setFilterValue('');
+      }
+      if (onToggle) {
+        onToggle(openValue, event);
+        return;
+      }
+      setIsVisible(openValue);
+    };
+    var closedWithoutChanges = useRef(true);
+    var updateValue = function updateValue(item, event) {
+      var _rest$onChangeValue2;
+      var newValue = item.dataset.value;
+      if (rest.valueType === 'multiple') {
+        var _rest$onChangeValue;
+        var _newSelected = getNewSelected(rest.value, newValue, rest.valueType);
+        (_rest$onChangeValue = rest.onChangeValue) === null || _rest$onChangeValue === void 0 || _rest$onChangeValue.call(rest, _newSelected);
+        return;
+      }
+      var newSelected = getNewSelected(rest.value, newValue, 'single');
+      (_rest$onChangeValue2 = rest.onChangeValue) === null || _rest$onChangeValue2 === void 0 || _rest$onChangeValue2.call(rest, newSelected);
+      onInnerToggle === null || onInnerToggle === void 0 || onInnerToggle(false, event);
+      closedWithoutChanges.current = false;
+    };
+    var onClickChildrenItem = function onClickChildrenItem(event) {
+      // INFO: Для корректной работы компонента Popper
+      event.stopPropagation();
+      var item = event.currentTarget;
+      updateValue(item, event);
+    };
+    var onChangeChipValue = function onChangeChipValue(newValue) {
+      var _rest$onChangeValue3;
+      if (rest.valueType !== 'multiple') {
+        return;
+      }
+      (_rest$onChangeValue3 = rest.onChangeValue) === null || _rest$onChangeValue3 === void 0 || _rest$onChangeValue3.call(rest, newValue);
+    };
+    var _useKeyNavigation = useKeyNavigation({
+        controlledRefs: controlledRefs,
+        opened: isVisible,
+        enumerationType: enumerationType,
+        valueType: valueType,
+        componentType: 'combobox',
+        value: value,
+        search: filterValue,
+        updateOpened: onInnerToggle,
+        updateValue: updateValue
+      }),
+      onKeyDownTarget = _useKeyNavigation.onKeyDownTarget,
+      onKeyDownSelect = _useKeyNavigation.onKeyDownSelect;
+    var childrenArray = Children.toArray(children);
+    var childrenMemo = getChildren(childrenArray, {
+      onClick: onClickChildrenItem,
+      childrenRefs: itemsRefs
+    }, value, filterValue, filterFunction).filter(Boolean);
+    var values = getValues(childrenArray, value);
+    var onSearch = function onSearch(newSearch, newOpened) {
+      setSearch(newSearch);
+      setFilterValue(newSearch);
+      setIsVisible(newOpened !== null && newOpened !== void 0 ? newOpened : true);
+    };
+    var onKeyDownHandle = function onKeyDownHandle(event) {
+      onKeyDown === null || onKeyDown === void 0 || onKeyDown(event);
+      onKeyDownTarget(event);
+    };
+    return /*#__PURE__*/React.createElement(StyledRoot, {
+      ref: comboboxRef
+    }, /*#__PURE__*/React.createElement(StyledNativeSelect, {
+      "aria-invalid": "false",
+      "aria-hidden": "true",
+      "aria-readonly": readOnly,
+      tabIndex: -1,
+      form: form,
+      name: name,
+      value: "".concat(value),
+      disabled: disabled || readOnly
+    }), /*#__PURE__*/React.createElement(StyledPopover, {
+      role: role,
+      opened: isVisible,
+      onToggle: onInnerToggle,
+      target: /*#__PURE__*/React.createElement(ComboboxTarget, _extends({
+        opened: isVisible,
+        values: values,
+        label: label,
+        placeholder: placeholder,
+        search: search,
+        enumerationType: enumerationType,
+        valueType: valueType,
+        readOnly: readOnly,
+        disabled: disabled,
+        size: size,
+        closedWithoutChanges: closedWithoutChanges,
+        ref: handleRef,
+        chipsRefs: chipsRefs,
+        inputRef: inputRef,
+        id: innerId,
+        onChange: onChangeChipValue,
+        onSearch: onSearch,
+        onKeyDown: onKeyDownHandle
+      }, rest)),
+      className: cx(ref === null || ref === void 0 ? void 0 : ref.classList.toString()) // INFO: Прокидываем стили для Popover
+      ,
+      id: innerId,
+      offset: offset,
+      placement: getPlacements(placement),
+      usePortal: usePortal,
+      selectWidth: dynamicTargetWidth,
+      frame: frame,
+      trigger: "click",
+      isFocusTrapped: false,
+      preventOverflow: false,
+      closeOnEsc: false,
+      closeOnOverlayClick: true
+    }, /*#__PURE__*/React.createElement(Root, {
+      ref: setRef,
+      view: view,
+      size: size
+    }, /*#__PURE__*/React.createElement(StyledCombobox, {
+      onKeyDown: onKeyDownSelect
+    }, childrenMemo.length ? childrenMemo : /*#__PURE__*/React.createElement(ComboboxItemNotFound, null, negativeResultContent)))));
+  });
+};
+export var comboboxConfig = {
+  name: 'Combobox',
+  tag: 'div',
+  layout: comboboxRoot,
+  base: '',
+  variations: {
+    view: {
+      css: viewCSS
+    },
+    size: {
+      css: sizeCSS
+    }
+  },
+  defaults: {
+    view: 'default',
+    size: 'm'
+  }
+};

package/styled-components/es/components/Combobox/Combobox.styles.js

@@ -0,0 +1,26 @@
+import styled from 'styled-components';
+import { component } from '../../engines';
+import { popoverClasses, popoverConfig } from '../Popover';
+import { tokens } from './Combobox.tokens';
+export var StyledRoot = /*#__PURE__*/styled.div.withConfig({
+  componentId: "plasma-new-hope__sc-gt7m6a-0"
+})(["width:100%;position:relative;& .", "{display:block;}"], popoverClasses.wrapper);
+export var StyledCombobox = /*#__PURE__*/styled.div.withConfig({
+  componentId: "plasma-new-hope__sc-gt7m6a-1"
+})(["box-sizing:border-box;background:var(", ");box-shadow:var(", ");border-radius:var(", ");width:var(", ");height:var(", ");padding:var(", ") var(", ") var(", ") var(", ");"], tokens.background, tokens.boxShadow, tokens.borderRadius, tokens.width, tokens.height, tokens.paddingTop, tokens.paddingRight, tokens.paddingBottom, tokens.paddingLeft);
+
+// issue #823
+var Popover = /*#__PURE__*/component(popoverConfig);
+export var StyledPopover = /*#__PURE__*/styled(Popover).withConfig({
+  componentId: "plasma-new-hope__sc-gt7m6a-2"
+})(["display:block;.", ",.", "{width:", ";}"], /*#__PURE__*/String(popoverClasses.root), /*#__PURE__*/String(popoverClasses.target), function (_ref) {
+  var usePortal = _ref.usePortal,
+    selectWidth = _ref.selectWidth;
+  return usePortal ? "".concat(selectWidth, "px") : '100%';
+});
+export var ComboboxItemNotFound = /*#__PURE__*/styled.div.withConfig({
+  componentId: "plasma-new-hope__sc-gt7m6a-3"
+})(["text-align:center;padding:0.5rem;font-family:var(", ");font-size:var(", ");font-style:var(", ");font-weight:var(", ");letter-spacing:var(", ");line-height:var(", ");"], tokens.itemFontFamily, tokens.itemFontSize, tokens.itemFontStyle, tokens.itemFontWeightBold, tokens.itemFontLetterSpacing, tokens.itemFontLineHeight);
+export var StyledNativeSelect = /*#__PURE__*/styled.select.withConfig({
+  componentId: "plasma-new-hope__sc-gt7m6a-4"
+})(["display:none;appearance:none;-moz-appearance:none;-webkit-appearance:none;background:transparent;color:transparent;border:none;outline:none;opacity:0;position:absolute;inset:0;"]);

package/styled-components/es/components/Combobox/Combobox.tokens.js

@@ -0,0 +1,184 @@
+export var classes = {
+  comboboxTargeText: 'combobox-target-text',
+  comboboxTargetLabel: 'combobox-button-label',
+  comboboxTargetInput: 'combobox-target-input',
+  comboboxTargetArrow: 'combobox-button-arrow',
+  arrowInverse: 'arrow-inverse',
+  comboboxItemIsSelected: 'combobox-item-is-selected',
+  comboboxItemIsDisabled: 'combobox-item-is-disabled',
+  hasChips: 'has-chips',
+  innerLabelUp: 'inner-label-up'
+};
+export var tokens = {
+  background: '--plasma-combobox-background',
+  boxShadow: '--plasma-combobox-box-shadow',
+  width: '--plasma-combobox-width',
+  height: '--plasma-combobox-height',
+  borderRadius: '--plasma-combobox-border-radius',
+  paddingTop: '--plasma-combobox-padding-top',
+  paddingRight: '--plasma-combobox-padding-right',
+  paddingBottom: '--plasma-combobox-padding-bottom',
+  paddingLeft: '--plasma-combobox-padding-left',
+  itemBackground: '--plasma-combobox-item-background',
+  itemColor: '--plasma-combobox-item-color',
+  itemBackgroundHover: '--plasma-combobox-item-background-hover',
+  itemBackgroundSelected: '--plasma-combobox-item-background-selected',
+  itemColorSelected: '--plasma-combobox-item-color-selected',
+  itemBackgroundSelectedHover: '--plasma-combobox-item-background-selected-hover',
+  itemColorSelectedHover: '--plasma-combobox-item-color-selected-hover',
+  itemWidth: '--plasma-combobox-item-width',
+  itemHeight: '--plasma-combobox-item-height',
+  itemBorderRadius: '--plasma-combobox-item-border-radius',
+  itemPaddingTop: '--plasma-combobox-item-padding-top',
+  itemPaddingRight: '--plasma-combobox-item-padding-right',
+  itemPaddingBottom: '--plasma-combobox-item-padding-bottom',
+  itemPaddingLeft: '--plasma-combobox-item-padding-left',
+  itemMarginTop: '--plasma-combobox-item-margin-top',
+  itemMarginRight: '--plasma-combobox-item-margin-right',
+  itemMarginBottom: '--plasma-combobox-item-margin-bottom',
+  itemMarginLeft: '--plasma-combobox-item-margin-left',
+  itemFontFamily: '--plasma-combobox-item-font-family',
+  itemFontSize: '--plasma-combobox-item-font-size',
+  itemFontStyle: '--plasma-combobox-item-font-style',
+  itemFontWeightBold: '--plasma-combobox-item-letter-spacing',
+  itemFontLetterSpacing: '--plasma-combobox-item-line-height',
+  itemFontLineHeight: '--plasma-combobox-item-font-weight',
+  itemContentLeftColor: '--plasma-combobox-item-content-left-color',
+  itemContentRightColor: '--plasma-combobox-item-content-right-color',
+  itemContentLeftWidth: '--plasma-combobox-item-content-left-width',
+  itemContentRightWidth: '--plasma-combobox-item-content-right-width',
+  footerBackground: '--plasma-combobox-footer-background',
+  footerWidth: '--plasma-combobox-footer-width',
+  footerHeight: '--plasma-combobox-footer-height',
+  footerPaddingTop: '--plasma-combobox-footer-padding-top',
+  footerPaddingRight: '--plasma-combobox-footer-padding-right',
+  footerPaddingBottom: '--plasma-combobox-footer-padding-bottom',
+  footerPaddingLeft: '--plasma-combobox-footer-padding-left',
+  footerMarginTop: '--plasma-combobox-footer-margin-top',
+  footerMarginRight: '--plasma-combobox-footer-margin-right',
+  footerMarginBottom: '--plasma-combobox-footer-margin-bottom',
+  footerMarginLeft: '--plasma-combobox-footer-margin-left',
+  footerFontFamily: '--plasma-combobox-footer-font-family',
+  footerFontSize: '--plasma-combobox-footer-font-size',
+  footerFontStyle: '--plasma-combobox-footer-font-style',
+  footerFontWeightBold: '--plasma-combobox-footer-letter-spacing',
+  footerFontLetterSpacing: '--plasma-combobox-footer-line-height',
+  footerFontLineHeight: '--plasma-combobox-footer-font-weight',
+  headerBackground: '--plasma-combobox-header-background',
+  headerWidth: '--plasma-combobox-header-width',
+  headerHeight: '--plasma-combobox-header-height',
+  headerPaddingTop: '--plasma-combobox-header-padding-top',
+  headerPaddingRight: '--plasma-combobox-header-padding-right',
+  headerPaddingBottom: '--plasma-combobox-header-padding-bottom',
+  headerPaddingLeft: '--plasma-combobox-header-padding-left',
+  headerMarginTop: '--plasma-combobox-header-margin-top',
+  headerMarginRight: '--plasma-combobox-header-margin-right',
+  headerMarginBottom: '--plasma-combobox-header-margin-bottom',
+  headerMarginLeft: '--plasma-combobox-header-margin-left',
+  headerFontFamily: '--plasma-combobox-header-font-family',
+  headerFontSize: '--plasma-combobox-header-font-size',
+  headerFontStyle: '--plasma-combobox-header-font-style',
+  headerFontWeightBold: '--plasma-combobox-header-letter-spacing',
+  headerFontLetterSpacing: '--plasma-combobox-header-line-height',
+  headerFontLineHeight: '--plasma-combobox-header-font-weight',
+  dividerColor: '--plasma-combobox-divider-color',
+  dividerWidth: '--plasma-combobox-divider-width',
+  dividerHeight: '--plasma-combobox-divider-height',
+  dividerMarginTop: '--plasma-combobox-divider-margin-top',
+  dividerMarginRight: '--plasma-combobox-divider-margin-right',
+  dividerMarginBottom: '--plasma-combobox-divider-margin-bottom',
+  dividerMarginLeft: '--plasma-combobox-divider-margin-left',
+  groupBackground: '--plasma-combobox-group-background',
+  groupWidth: '--plasma-combobox-group-width',
+  groupHeight: '--plasma-combobox-group-height',
+  groupPaddingTop: '--plasma-combobox-group-padding-top',
+  groupPaddingRight: '--plasma-combobox-group-padding-right',
+  groupPaddingBottom: '--plasma-combobox-group-padding-bottom',
+  groupPaddingLeft: '--plasma-combobox-group-padding-left',
+  groupMarginTop: '--plasma-combobox-group-margin-top',
+  groupMarginRight: '--plasma-combobox-group-margin-right',
+  groupMarginBottom: '--plasma-combobox-group-margin-bottom',
+  groupMarginLeft: '--plasma-combobox-group-margin-left',
+  groupLabelColor: '--plasma-combobox-group-label-color',
+  groupLabelFontFamily: '--plasma-combobox-group-label-font-family',
+  groupLabelFontSize: '--plasma-combobox-group-label-font-size',
+  groupLabelFontStyle: '--plasma-combobox-group-label-font-style',
+  groupLabelFontWeight: '--plasma-combobox-group-label-font-weight',
+  groupLabelLetterSpacing: '--plasma-combobox-group-label-letter-spacing',
+  groupLabelLineHeight: '--plasma-combobox-group-label-line-height',
+  groupLabelPaddingTop: '--plasma-combobox-group-label-padding-top',
+  groupLabelPaddingRight: '--plasma-combobox-group-label-padding-right',
+  groupLabelPaddingBottom: '--plasma-combobox-group-label-padding-bottom',
+  groupLabelPaddingLeft: '--plasma-combobox-group-label-padding-left',
+  groupLabelMarginTop: '--plasma-combobox-group-label-margin-top',
+  groupLabelMarginRight: '--plasma-combobox-group-label-margin-right',
+  groupLabelMarginBottom: '--plasma-combobox-group-label-margin-bottom',
+  groupLabelMarginLeft: '--plasma-combobox-group-label-margin-left',
+  targetColor: '--plasma-combobox-target-color',
+  targetLabelColor: '--plasma-combobox-target-label-color',
+  targetArrowColor: '--plasma-combobox-target-arrow-color',
+  targetArrowRight: '--plasma-combobox-target-arrow-right',
+  targetBackgroundColor: '--plasma-combobox-target-background-color',
+  targetBackgroundColorHover: '--plasma-combobox-target-background-color-hover',
+  targetBackgroundColorActive: '--plasma-combobox-target-background-color-active',
+  targetBackgroundColorOpen: '--plasma-combobox-target-background-color-open',
+  targetBorderColor: '--plasma-combobox-target-border-color',
+  targetBorderColorHover: '--plasma-combobox-target-border-color-hover',
+  targetBorderColorActive: '--plasma-combobox-target-border-color-active',
+  targetBorderColorOpen: '--plasma-combobox-target-border-color-open',
+  targetInnerTop: '--plasma-combobox-target-inner-top',
+  targetPadding: '--plasma-combobox-target-padding',
+  targetPaddingWithInput: '--plasma-combobox-target-with-input',
+  targetPaddingHasChips: '--plasma-combobox-target-padding-has-chips',
+  targetHeight: '--plasma-combobox-target-height',
+  targetWidth: '--plasma-combobox-target-width',
+  targetRadius: '--plasma-combobox-target-radius',
+  targetFontFamily: '--plasma-combobox-target-font-family',
+  targetFontSize: '--plasma-combobox-target-font-size',
+  targetFontStyle: '--plasma-combobox-target-font-style',
+  targetFontWeight: '--plasma-combobox-target-font-weight',
+  targetLetterSpacing: '--plasma-combobox-target-letter-spacing',
+  targetLineHeight: '--plasma-combobox-target-line-height',
+  targetLabelInnerTop: '--plasma-combobox-target-label-inner-top',
+  targetLabelInnerFontFamily: '--plasma-combobox-target-label-inner-font-family',
+  targetLabelInnerFontSize: '--plasma-combobox-target-label-inner-font-family',
+  targetLabelInnerFontStyle: '--plasma-combobox-target-label-inner-font-style',
+  targetLabelInnerFontWeight: '--plasma-combobox-target-label-inner-font-weight',
+  targetLabelInnerLetterSpacing: '--plasma-combobox-target-label-inner-letter-spacing',
+  targetLabelInnerLineHeight: '--plasma-combobox-target-label-inner-line-height',
+  chipGap: '--plasma-combobox-chip-gap',
+  chipBackground: '--plasma-combobox-chip-background',
+  chipColor: '--plasma-combobox-chip-color',
+  chipBackgroundHover: '--plasma-combobox-chip-background-hover',
+  chipColorHover: '--plasma-combobox-chip-color-hover',
+  chipScaleHover: '--plasma-combobox-chip-scale-hover',
+  chipBackgroundReadOnly: '--plasma-combobox-chip-background-readonly',
+  chipColorReadOnly: '--plasma-combobox-chip-color-readonly',
+  chipBackgroundReadOnlyHover: '--plasma-combobox-chip-background-readonly-hover',
+  chipColorReadOnlyHover: '--plasma-combobox-chip-color-readonly-hover',
+  chipBackgroundActive: '--plasma-combobox-chip-background-active',
+  chipColorActive: '--plasma-combobox-chip-color-active',
+  chipScaleActive: '--plasma-combobox-chip-scale-active',
+  chipFocusColor: '--plasma-combobox-chip-focus-color',
+  chipCloseIconColor: '--plasma-combobox-chip-close-icon-color',
+  chipOutlineSize: '--plasma-combobox-chip-outline-size',
+  chipBorderRadius: '--plasma-combobox-chip-border-radius',
+  chipWidth: '--plasma-combobox-chip-width',
+  chipHeight: '--plasma-combobox-chip-height',
+  chipPaddingTop: '--plasma-combobox-chip-padding-top',
+  chipPaddingRight: '--plasma-combobox-chip-padding-right',
+  chipPaddingBottom: '--plasma-combobox-chip-padding-bottom',
+  chipPaddingLeft: '--plasma-combobox-chip-padding-left',
+  chipCloseIconSize: '--plasma-combobox-chip-close-icon-size',
+  chipFontFamily: '--plasma-combobox-chip-font-family',
+  chipFontSize: '--plasma-combobox-chip-font-size',
+  chipFontStyle: '--plasma-combobox-chip-font-style',
+  chipFontWeight: '--plasma-combobox-chip-font-weight',
+  chipLetterSpacing: '--plasma-combobox-chip-letter-spacing',
+  chipLineHeight: '--plasma-combobox-chip-line-height',
+  chipClearContentMarginLeft: '--plasma-combobox-chip-clear-content-margin-left',
+  chipClearContentMarginRight: '--plasma-combobox-chip-clear-content-margin-right',
+  chipOpacityReadonly: '--plasma-combobox-chip-opacity-readonly',
+  disabledOpacity: '--plasma-combobox-disabled-opacity',
+  focusColor: '--plasma-combobox-focus-color'
+};

package/styled-components/es/components/Combobox/hooks/useFocusController.js

@@ -0,0 +1,125 @@
+import { useEffect } from 'react';
+import { useDidMountEffect, usePreviousValue } from '../../../hooks';
+export var useFocusController = function useFocusController(_ref) {
+  var _ref$controlledRefs = _ref.controlledRefs,
+    contentRef = _ref$controlledRefs.contentRef,
+    inputHelperRef = _ref$controlledRefs.inputHelperRef,
+    inputRef = _ref$controlledRefs.inputRef,
+    opened = _ref.opened,
+    hasValue = _ref.hasValue,
+    textContent = _ref.textContent,
+    search = _ref.search,
+    values = _ref.values,
+    readOnly = _ref.readOnly,
+    valueType = _ref.valueType,
+    closedWithoutChanges = _ref.closedWithoutChanges,
+    updateSearch = _ref.updateSearch,
+    updateFocused = _ref.updateFocused,
+    onChipClick = _ref.onChipClick;
+  var prevSearch = usePreviousValue(search);
+  var prevValues = usePreviousValue(values);
+  var prevOpened = usePreviousValue(opened);
+  useDidMountEffect(function () {
+    if (!opened) {
+      var _contentRef$current;
+      updateFocused(false);
+      (_contentRef$current = contentRef.current) === null || _contentRef$current === void 0 || _contentRef$current.scrollTo({
+        left: 0
+      });
+    }
+    var hasFocusAfterClose = prevOpened !== undefined && !opened && !(closedWithoutChanges !== null && closedWithoutChanges !== void 0 && closedWithoutChanges.current);
+    if (opened || hasFocusAfterClose) {
+      var _inputRef$current;
+      (_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 || _inputRef$current.focus();
+    }
+
+    // INFO: Помогает определить, произошло ли закрытие выпадающего меню при выборе значения.
+    // Нужно для того, чтобы не фокусироваться на инпуте
+    // ОЧЕНЬ не нравится это решение, но оно работает
+    if ((closedWithoutChanges === null || closedWithoutChanges === void 0 ? void 0 : closedWithoutChanges.current) === false) {
+      closedWithoutChanges.current = true;
+    }
+  }, [opened]);
+  useDidMountEffect(function () {
+    var prevValuesCount = (prevValues === null || prevValues === void 0 ? void 0 : prevValues.length) || 0;
+    var valuesCount = (values === null || values === void 0 ? void 0 : values.length) || 0;
+    if ((opened || prevOpened) && prevValuesCount < valuesCount) {
+      var _inputRef$current2;
+      (_inputRef$current2 = inputRef.current) === null || _inputRef$current2 === void 0 || _inputRef$current2.focus();
+    }
+  }, [values, readOnly]);
+  useDidMountEffect(function () {
+    if (!inputRef.current) {
+      return;
+    }
+
+    // INFO: Для multiple
+    if (search === '') {
+      inputRef.current.style.flex = '1';
+    }
+
+    // INFO: Для single
+    if (!opened && prevSearch !== search) {
+      inputRef.current.style.flex = '1';
+    }
+
+    // INFO: Для кейсов, когда значение вырезано
+    if (!inputRef.current.value.length) {
+      inputRef.current.style.flex = '1';
+      return;
+    }
+    if (valueType === 'multiple' && inputHelperRef.current) {
+      var clientWidth = inputHelperRef.current.clientWidth;
+      inputRef.current.style.flex = "1 0 ".concat(clientWidth, "px");
+    }
+  }, [readOnly, search, valueType]);
+  useEffect(function () {
+    var newSearch = hasValue ? textContent : '';
+
+    // INFO: Заполнить поле input при первой инициализации
+    if (prevOpened !== undefined && opened) {
+      return;
+    }
+    if (valueType === 'single') {
+      updateSearch === null || updateSearch === void 0 || updateSearch(newSearch, false);
+    }
+    if (valueType === 'multiple') {
+      updateSearch === null || updateSearch === void 0 || updateSearch('', false);
+    }
+  }, [updateSearch, values, opened, hasValue, textContent, valueType]);
+  var onClickText = function onClickText(event) {
+    var _inputRef$current3;
+    onChipClick === null || onChipClick === void 0 || onChipClick(event);
+    (_inputRef$current3 = inputRef.current) === null || _inputRef$current3 === void 0 || _inputRef$current3.focus();
+  };
+  var onFocusInput = function onFocusInput() {
+    var _contentRef$current2, _contentRef$current3;
+    if (readOnly) {
+      return;
+    }
+
+    // INFO: Жёсткий хак, нужный для корректного выделения всей строки после выбора значения.
+    // Проблема возникает из-за очередности срабатывания useEffect, который сначала вызывает фокус
+    // на элемент, а потом обновляет состояние inputRef
+    if (valueType === 'single') {
+      setTimeout(function () {
+        var _inputRef$current4;
+        (_inputRef$current4 = inputRef.current) === null || _inputRef$current4 === void 0 || _inputRef$current4.select();
+      });
+    }
+    (_contentRef$current2 = contentRef.current) === null || _contentRef$current2 === void 0 || _contentRef$current2.scrollTo({
+      left: (_contentRef$current3 = contentRef.current) === null || _contentRef$current3 === void 0 ? void 0 : _contentRef$current3.scrollWidth
+    });
+    updateFocused(true);
+  };
+  var onBlurInput = function onBlurInput() {
+    if (!opened) {
+      updateFocused(false);
+    }
+  };
+  return {
+    onClickText: onClickText,
+    onFocusInput: onFocusInput,
+    onBlurInput: onBlurInput
+  };
+};

package/styled-components/es/components/Combobox/index.js

@@ -1,2 +1,3 @@
-export { comboboxRoot as comboboxOldRoot, comboboxConfig as comboboxOldConfig, comboboxDividerRoot, comboboxDividerConfig, comboboxFooterRoot, comboboxFooterConfig, comboboxGroupRoot, comboboxGroupConfig, comboboxHeaderRoot, comboboxHeaderConfig, comboboxItemRoot, comboboxItemConfig, ComboboxTarget, comboboxClasses as comboboxOldClasses, comboboxTokens as comboboxOldTokens } from './ComboboxOld';
-export { comboboxTokens as comboboxNewTokens, comboboxRoot as comboboxNewRoot, comboboxConfig as comboboxNewConfig } from './ComboboxNew';
+export { comboboxRoot, comboboxConfig } from './Combobox';
+export { classes as comboboxClasses, tokens as comboboxTokens } from './Combobox.tokens';
+export * from './ui';

package/styled-components/es/components/Combobox/ui/ComboboxChip/ComboboxChip.styles.js

@@ -0,0 +1,19 @@
+import styled from 'styled-components';
+import { chipConfig, chipTokens } from '../../../Chip';
+import { component, mergeConfig } from '../../../../engines';
+import { tokens } from '../../Combobox.tokens';
+import { addFocus } from '../../../../mixins';
+
+// issue #823
+var mergedConfig = /*#__PURE__*/mergeConfig(chipConfig);
+var Chip = /*#__PURE__*/component(mergedConfig);
+
+// NOTE: Необходимое переопределение токенов из компонента Chip т.к. используются его части
+export var StyledChip = /*#__PURE__*/styled(Chip).withConfig({
+  componentId: "plasma-new-hope__sc-194p1l0-0"
+})(["", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", " &[readonly]{opacity:var(", ");}"], chipTokens.color, tokens.chipColor, chipTokens.background, tokens.chipBackground, chipTokens.colorHover, tokens.chipColorHover, chipTokens.backgroundHover, tokens.chipBackgroundHover, chipTokens.colorActive, tokens.chipColorActive, chipTokens.backgroundActive, tokens.chipBackgroundActive, chipTokens.backgroundReadOnly, tokens.chipBackgroundReadOnly, chipTokens.colorReadOnly, tokens.chipColorReadOnly, chipTokens.backgroundReadOnlyHover, tokens.chipBackgroundReadOnlyHover, chipTokens.colorReadOnlyHover, tokens.chipColorReadOnlyHover, chipTokens.borderRadius, tokens.chipBorderRadius, chipTokens.width, tokens.chipWidth, chipTokens.height, tokens.chipHeight, chipTokens.paddingRight, tokens.chipPaddingRight, chipTokens.paddingLeft, tokens.chipPaddingLeft, chipTokens.fontFamily, tokens.chipFontFamily, chipTokens.fontSize, tokens.chipFontSize, chipTokens.fontStyle, tokens.chipFontStyle, chipTokens.fontWeight, tokens.chipFontWeight, chipTokens.letterSpacing, tokens.chipLetterSpacing, chipTokens.lineHeight, tokens.chipLineHeight, chipTokens.clearContentMarginLeft, tokens.chipClearContentMarginLeft, chipTokens.clearContentMarginRight, tokens.chipClearContentMarginRight, chipTokens.scaleHover, tokens.chipScaleHover, chipTokens.scaleActive, tokens.chipScaleActive, chipTokens.closeIconSize, tokens.chipCloseIconSize, chipTokens.closeIconColor, tokens.chipCloseIconColor, chipTokens.focusColor, tokens.focusColor, /*#__PURE__*/addFocus({
+  outlineOffset: '0.125rem',
+  outlineSize: '0.0625rem',
+  outlineRadius: /*#__PURE__*/"calc(var(".concat(tokens.chipBorderRadius, ") - 0.1rem)"),
+  outlineColor: /*#__PURE__*/"var(".concat(tokens.focusColor, ")")
+}), tokens.chipOpacityReadonly);

package/styled-components/es/components/Combobox/ui/ComboboxDivider/ComboboxDivider.js

@@ -0,0 +1,23 @@
+import { dropdownDividerRoot } from '../../../Dropdown';
+import { base as viewCSS } from './variations/_view/base';
+import { base as sizeCSS } from './variations/_size/base';
+import { base } from './ComboboxDivider.styles';
+export var comboboxDividerRoot = dropdownDividerRoot;
+export var comboboxDividerConfig = {
+  name: 'ComboboxDivider',
+  tag: 'div',
+  layout: comboboxDividerRoot,
+  base: base,
+  variations: {
+    view: {
+      css: viewCSS
+    },
+    size: {
+      css: sizeCSS
+    }
+  },
+  defaults: {
+    view: 'primary',
+    size: 'm'
+  }
+};

package/styled-components/es/components/Combobox/ui/ComboboxDivider/ComboboxDivider.styles.js

@@ -0,0 +1,7 @@
+import { css } from 'styled-components';
+import { tokens } from '../../Combobox.tokens';
+import { dropdownTokens } from '../../../Dropdown';
+
+// NOTE: Необходимое переопределение токенов из компонента DropdownItem т.к. используются его части
+export var mappingOverride = /*#__PURE__*/css(["", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");", ":var(", ");"], dropdownTokens.dividerColor, tokens.dividerColor, dropdownTokens.dividerWidth, tokens.dividerWidth, dropdownTokens.dividerHeight, tokens.dividerHeight, dropdownTokens.dividerMarginTop, tokens.dividerMarginTop, dropdownTokens.dividerMarginRight, tokens.dividerMarginRight, dropdownTokens.dividerMarginBottom, tokens.dividerMarginBottom, dropdownTokens.dividerMarginLeft, tokens.dividerMarginLeft);
+export var base = mappingOverride;