@salutejs/plasma-new-hope 0.71.3-canary.1161.8619854344.0 → 0.72.0-canary.1160.8612911363.0

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

@@ -1,91 +1,221 @@
-var _excluded = ["contentLeft", "contentRight", "children", "label", "labelPlacement", "placeholder", "leftHelper", "view", "size", "disabled", "onChange", "onSearch"];
+var _excluded = ["id", "contentLeft", "contentRight", "label", "labelPlacement", "placeholder", "leftHelper", "enumerationType", "view", "size", "readOnly", "disabled", "values", "onChange", "onChangeChips", "onSearch"];
 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, { forwardRef } from 'react';
-import { css } from 'styled-components';
+import React, { forwardRef, useEffect, useRef, useState } from 'react';
 import { safeUseId } from '@salutejs/plasma-core';
-import { base as size } from './_size/base';
-import { base as view } from './_view/base';
-import { base as disabled } from './_disabled/base';
-import { base as labelPlacement } from './_label-placement/base';
-import { Input, LeftHelper, Label, InputWrapper, InputLabelWrapper } from './TextField.styles';
-var base = /*#__PURE__*/css(["display:block;"]);
+import { css } from 'styled-components';
+import { cx } from '../../utils';
+import { base as sizeCSS } from './variations/_size/base';
+import { base as viewCSS } from './variations/_view/base';
+import { base as disabledCSS } from './variations/_disabled/base';
+import { base as readOnlyCSS } from './variations/_read-only/base';
+import { base as labelPlacementCSS } from './variations/_label-placement/base';
+import { Input, LeftHelper, Label, InputWrapper, InputLabelWrapper, StyledContentLeft, StyledContentRight, StyledChips } from './TextField.styles';
+import { classes } from './TextField.tokens';
+import { TextFieldChip } from './ui';
+import { useKeyNavigation } from './hooks/useKeyNavigation';
+export var base = /*#__PURE__*/css(["display:block;overflow:hidden;"]);
 export var textFieldRoot = function textFieldRoot(Root) {
-  return /*#__PURE__*/forwardRef(function (props, ref) {
-    var contentLeft = props.contentLeft,
-      contentRight = props.contentRight,
-      children = props.children,
-      label = props.label,
-      labelPlacement = props.labelPlacement,
-      placeholder = props.placeholder,
-      leftHelper = props.leftHelper,
-      view = props.view,
-      size = props.size,
-      disabled = props.disabled,
-      onChange = props.onChange,
-      onSearch = props.onSearch,
-      rest = _objectWithoutProperties(props, _excluded);
+  return /*#__PURE__*/forwardRef(function (_ref, ref) {
+    var id = _ref.id,
+      contentLeft = _ref.contentLeft,
+      contentRight = _ref.contentRight,
+      label = _ref.label,
+      labelPlacement = _ref.labelPlacement,
+      placeholder = _ref.placeholder,
+      leftHelper = _ref.leftHelper,
+      _ref$enumerationType = _ref.enumerationType,
+      enumerationType = _ref$enumerationType === void 0 ? 'plain' : _ref$enumerationType,
+      view = _ref.view,
+      size = _ref.size,
+      _ref$readOnly = _ref.readOnly,
+      readOnly = _ref$readOnly === void 0 ? false : _ref$readOnly,
+      _ref$disabled = _ref.disabled,
+      disabled = _ref$disabled === void 0 ? false : _ref$disabled,
+      values = _ref.values,
+      onChange = _ref.onChange,
+      onChangeChips = _ref.onChangeChips,
+      onSearch = _ref.onSearch,
+      rest = _objectWithoutProperties(_ref, _excluded);
+    var contentRef = useRef(null);
+    var inputRef = useRef(null);
+    var chipsRefs = useRef([]);
+    var controlledRefs = {
+      contentRef: contentRef,
+      inputRef: inputRef,
+      chipsRefs: chipsRefs
+    };
+    var _useState = useState([]),
+      _useState2 = _slicedToArray(_useState, 2),
+      chips = _useState2[0],
+      setChips = _useState2[1];
+    var uniqId = safeUseId();
+    var innerId = id || uniqId;
+    var labelId = safeUseId();
+    var helperTextId = safeUseId();
+    var isChipEnumeration = enumerationType === 'chip';
+    var hideLabel = (size === 'xs' || isChipEnumeration) && labelPlacement === 'inner';
+    var labelInside = size !== 'xs' && labelPlacement === 'inner';
+    var innerLabelPlacementValue = hideLabel ? 'outer' : labelPlacement;
+    var innerPlaceholderValue = hideLabel ? label : placeholder;
+    var innerLabelValue = hideLabel ? undefined : label;
+    var isChipsVisible = isChipEnumeration && (chips === null || chips === void 0 ? void 0 : chips.length);
+    var withHasChips = isChipsVisible ? classes.hasChips : undefined;
+    var wrapperWithoutLeftContent = !contentLeft && isChipsVisible ? classes.hasEmptyContentLeft : undefined;
+    var wrapperWithoutRightContent = !contentRight && isChipsVisible ? classes.hasEmptyContentRight : undefined;
     var handleChange = function handleChange(event) {
+      if (disabled || readOnly) {
+        return;
+      }
       var _event$target = event.target,
         maxLength = _event$target.maxLength,
         value = _event$target.value;
-      if (!onChange || maxLength !== -1 && value.length > maxLength) {
+      if (maxLength !== -1 && value.length > maxLength) {
+        return;
+      }
+      onChange === null || onChange === void 0 ? void 0 : onChange(event);
+    };
+    var updateChips = function updateChips(newChips, newValues) {
+      setChips(newChips);
+      onChangeChips === null || onChangeChips === void 0 ? void 0 : onChangeChips(newValues);
+    };
+    var _useKeyNavigation = useKeyNavigation({
+        controlledRefs: controlledRefs,
+        disabled: disabled,
+        readOnly: readOnly,
+        chips: chips,
+        enumerationType: enumerationType,
+        updateChips: updateChips,
+        onSearch: onSearch,
+        onChange: onChange
+      }),
+      handleInputKeydown = _useKeyNavigation.handleInputKeydown,
+      handleChipKeyDown = _useKeyNavigation.handleChipKeyDown,
+      onChipClear = _useKeyNavigation.onChipClear,
+      handleContentKeyDown = _useKeyNavigation.handleContentKeyDown;
+    var onChipClick = function onChipClick(event) {
+      return event.stopPropagation();
+    };
+    var handleInputFocus = function handleInputFocus() {
+      if (readOnly || disabled || !(inputRef !== null && inputRef !== void 0 && inputRef.current)) {
         return;
       }
-      onChange(event);
+      inputRef.current.scrollIntoView({
+        behavior: 'smooth',
+        block: 'center',
+        inline: 'center'
+      });
+      inputRef.current.focus({
+        preventScroll: true
+      });
     };
-    var handleKeyUp = function handleKeyUp(event) {
-      if (event.key === 'Enter' && onSearch) {
-        onSearch(event.target.value, event);
+    var getRef = function getRef(element, index) {
+      if (element && chipsRefs !== null && chipsRefs !== void 0 && chipsRefs.current) {
+        chipsRefs.current[index] = element;
       }
     };
-    var labelInside = labelPlacement === 'inner';
-    var lableId = safeUseId();
-    var helperTextId = safeUseId();
+    useEffect(function () {
+      if (!isChipEnumeration && !(values !== null && values !== void 0 && values.length)) {
+        return;
+      }
+      var newChips = (values === null || values === void 0 ? void 0 : values.map(function (value, index) {
+        return {
+          id: "".concat(index, "_").concat(value),
+          text: value
+        };
+      })) || [];
+      setChips(newChips);
+    }, [isChipEnumeration, values]);
     return /*#__PURE__*/React.createElement(Root, {
+      ref: ref,
       view: view,
       size: size,
       disabled: disabled,
-      labelPlacement: labelPlacement
-    }, labelInside || label && /*#__PURE__*/React.createElement(Label, {
-      id: lableId
-    }, label), /*#__PURE__*/React.createElement(InputWrapper, null, contentLeft, /*#__PURE__*/React.createElement(InputLabelWrapper, null, /*#__PURE__*/React.createElement(Input, _extends({}, rest, {
-      ref: ref,
-      "aria-labelledby": lableId,
+      readOnly: !disabled && readOnly,
+      labelPlacement: innerLabelPlacementValue,
+      onClick: handleInputFocus
+    }, labelInside || innerLabelValue && /*#__PURE__*/React.createElement(Label, {
+      id: labelId,
+      htmlFor: id
+    }, innerLabelValue), /*#__PURE__*/React.createElement(InputWrapper, {
+      className: cx(withHasChips, wrapperWithoutLeftContent, wrapperWithoutRightContent)
+    }, contentLeft && /*#__PURE__*/React.createElement(StyledContentLeft, null, contentLeft), /*#__PURE__*/React.createElement(InputLabelWrapper, {
+      tabIndex: -1,
+      ref: contentRef,
+      onKeyDown: handleContentKeyDown,
+      className: withHasChips
+    }, isChipEnumeration && Boolean(chips === null || chips === void 0 ? void 0 : chips.length) && /*#__PURE__*/React.createElement(StyledChips, null, chips === null || chips === void 0 ? void 0 : chips.map(function (_ref2, index) {
+      var chipId = _ref2.id,
+        text = _ref2.text;
+      return /*#__PURE__*/React.createElement(TextFieldChip, {
+        ref: function ref(element) {
+          return getRef(element, index);
+        },
+        chipId: chipId,
+        key: "".concat(chipId, "_").concat(index),
+        disabled: disabled,
+        readOnly: readOnly,
+        value: text,
+        text: text,
+        onKeyDown: function onKeyDown(event) {
+          return handleChipKeyDown(event, chipId);
+        },
+        onClear: function onClear() {
+          return onChipClear(chipId);
+        },
+        onClick: onChipClick
+      });
+    })), /*#__PURE__*/React.createElement(Input, _extends({}, rest, {
+      ref: inputRef,
+      id: innerId,
+      "aria-labelledby": labelId,
       "aria-describedby": helperTextId,
-      placeholder: placeholder,
+      placeholder: innerPlaceholderValue,
       disabled: disabled,
+      readOnly: !disabled && readOnly,
       onChange: handleChange,
-      onKeyUp: handleKeyUp
+      onKeyDown: handleInputKeydown
     })), labelInside && /*#__PURE__*/React.createElement(Label, {
-      id: lableId
-    }, label)), contentRight), leftHelper && /*#__PURE__*/React.createElement(LeftHelper, {
+      id: labelId,
+      htmlFor: innerId
+    }, innerLabelValue)), contentRight && /*#__PURE__*/React.createElement(StyledContentRight, null, contentRight)), leftHelper && /*#__PURE__*/React.createElement(LeftHelper, {
       id: helperTextId
     }, leftHelper));
   });
 };
 export var textFieldConfig = {
   name: 'TextField',
-  tag: 'label',
+  tag: 'div',
   layout: textFieldRoot,
   base: base,
   variations: {
     view: {
-      css: view
+      css: viewCSS
     },
     size: {
-      css: size
+      css: sizeCSS
     },
     disabled: {
-      css: disabled,
+      css: disabledCSS,
+      attrs: true
+    },
+    readOnly: {
+      css: readOnlyCSS,
       attrs: true
     },
     labelPlacement: {
-      css: labelPlacement
+      css: labelPlacementCSS
     }
   },
   defaults: {
-    size: 'm'
+    size: 'm',
+    view: 'default'
   }
 };

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

@@ -1,18 +1,26 @@
 import styled from 'styled-components';
-export var Input = /*#__PURE__*/styled.input.withConfig({
+import { classes, tokens } from './TextField.tokens';
+export var InputWrapper = /*#__PURE__*/styled.div.withConfig({
   componentId: "plasma-new-hope__sc-g4vxbb-0"
-})(["box-sizing:border-box;appearance:none;border:0;padding:0;background-color:transparent;outline:none;"]);
+})(["position:relative;display:flex;align-items:center;box-sizing:border-box;"]);
 export var InputLabelWrapper = /*#__PURE__*/styled.div.withConfig({
   componentId: "plasma-new-hope__sc-g4vxbb-1"
-})(["", "{width:100%;}"], Input);
-
-// NOTE: border-width is used in size border-color is used in view
-export var InputWrapper = /*#__PURE__*/styled.div.withConfig({
+})(["flex:1;overflow:scroll;position:relative;width:100%;display:inline-flex;align-items:center;::-webkit-scrollbar{display:none;}scrollbar-width:none;overscroll-behavior:contain;&.", "{height:var(", ");border-radius:var(", ");}"], /*#__PURE__*/String(classes.hasChips), tokens.chipHeight, tokens.chipBorderRadius);
+export var StyledChips = /*#__PURE__*/styled.div.withConfig({
   componentId: "plasma-new-hope__sc-g4vxbb-2"
-})(["position:relative;display:flex;align-items:center;box-shadow:inset 0 0 0 var(--plasma_private-textfield-border-width) var(--plasma_private-textfield-border-color);", "{flex-grow:1;}"], InputLabelWrapper);
-export var Label = /*#__PURE__*/styled.div.withConfig({
+})(["display:flex;gap:var(", ");margin-right:var(", ");user-select:none;"], tokens.chipGap, tokens.chipGap);
+export var Input = /*#__PURE__*/styled.input.withConfig({
   componentId: "plasma-new-hope__sc-g4vxbb-3"
+})(["box-sizing:border-box;appearance:none;border:0;padding:0;background-color:transparent;outline:none;flex:1;min-width:60%;"]);
+export var Label = /*#__PURE__*/styled.label.withConfig({
+  componentId: "plasma-new-hope__sc-g4vxbb-4"
 })([""]);
+export var StyledContentLeft = /*#__PURE__*/styled.div.withConfig({
+  componentId: "plasma-new-hope__sc-g4vxbb-5"
+})(["margin:var(", ");"], tokens.leftContentMargin);
+export var StyledContentRight = /*#__PURE__*/styled.div.withConfig({
+  componentId: "plasma-new-hope__sc-g4vxbb-6"
+})(["margin:var(", ");"], tokens.rightContentMargin);
 export var LeftHelper = /*#__PURE__*/styled.div.withConfig({
-  componentId: "plasma-new-hope__sc-g4vxbb-4"
+  componentId: "plasma-new-hope__sc-g4vxbb-7"
 })([""]);

package/styled-components/es/components/TextField/TextField.template-doc.mdx

@@ -110,3 +110,27 @@ export function App() {
     );
 }
 ```
+
+### Режим ввода
+С помощью свойства `enumarationType` можно вводить элементы как теги. 
+По нажатию Enter, после ввода нужного текста, он преобразуется в Chip:
+
+```tsx live
+import React from 'react';
+import { TextField } from '@salutejs/{{ package }};
+
+export function App() {
+    return (
+        <div>
+            <TextField
+                placeholder="Введите значение"
+                defaultValue="Значение"
+                size="l"
+                enumerationType="chip"
+                helperText="Подсказка снизу"
+                values={["Значение 1"]}
+            />
+        </div>
+    );
+}
+```

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

@@ -1,31 +1,42 @@
+export var classes = {
+  hasChips: 'has-chips',
+  hasEmptyContentLeft: 'has-empty-content-left',
+  hasEmptyContentRight: 'has-empty-content-right'
+};
 export var tokens = {
   color: '--plasma-textfield-color',
   backgroundColor: '--plasma-textfield-bg-color',
   backgroundColorHover: '--plasma-textfield-bg-color-hover',
   backgroundColorFocus: '--plasma-textfield-bg-color-focus',
-  /** Цвет каретки */
-  caretColor: '--plasma-textfield__caret-color',
-  placeholderColor: '--plasma-textfield__placeholder-color',
   borderColor: '--plasma-textfield-border-color',
   borderColorHover: '--plasma-textfield-border-color-hover',
   borderColorFocus: '--plasma-textfield-border-color-focus',
+  /** Цвета для read-only состояния */
+  colorReadOnly: '--plasma-textfield-color-readonly',
+  backgroundColorReadOnly: '--plasma-textfield-bg-color-readonly',
+  borderColorReadOnly: '--plasma-textfield-border-color-readonly',
+  placeholderColorReadOnly: '--plasma-textfield__placeholder-color-readonly',
+  /** Цвет каретки */
+  caretColor: '--plasma-textfield__caret-color',
+  placeholderColor: '--plasma-textfield__placeholder-color',
   height: '--plasma-textfield-height',
   borderWidth: '--plasmas-textfield-border-width',
   borderRadius: '--plasma-textfield-border-radius',
-  /** отступ от границы ТextField */
+  /** Отступ от границы ТextField */
   padding: '--plasma-textfield-padding',
-  paddingWithContent: '--plasma-textfield-padding-with-content',
-  /* Отступ между Иконками и текстом Инпута */
-  /* Отступ при отсутствии Иконок сохраняется */
-  contentOffset: '--plasma-textfield__content-offset',
+  paddingWithChips: '--plasma-textfield-padding-with-chips',
+  /* Токены для инпута */
+  leftContentMargin: '--plasma-textfield__left-content-margin',
+  rightContentMargin: '--plasma-textfield__right-content-margin',
   fontFamily: '--plasma-textfield-font-family',
   fontStyle: '--plasma-textfield-font-style',
   fontSize: '--plasma-textfield-font-size',
   fontWeight: '--plasma-textfield-font-weight',
   letterSpacing: '--plasma-textfield-letter-spacing',
   lineHeight: '--plasma-textfield-line-height',
-  /** Цвет подписи */
+  /** Токены лейбла */
   labelColor: '--plasma-textfield__label-color',
+  labelColorReadOnly: '--plasma-textfield__label-color-readonly',
   labelOffset: '--plasma-textfield__label-offset',
   labelFontFamily: '--plasma-textfield__label-font-family',
   labelFontStyle: '--plasma-textfield__label-font-style',
@@ -40,16 +51,52 @@ export var tokens = {
   labelInnerFontWeight: '--plasma-textfield-placement_inner__label-font-weight',
   labelInnerLetterSpacing: '--plasma-textfield-placement_inner__label-letter-spacing',
   labelInnerLineHeight: '--plasma-textfield-placement_inner__label-line-height',
-  leftHelperColor: '--plasma-textfield__leftHelper-color',
-  leftHelperOffset: '--plasma-textfield__leftHelper-offset',
-  leftHelperFontFamily: '--plasma-textfield__leftHelper-font-family',
-  leftHelperFontStyle: '--plasma-textfield__leftHelper-font-style',
-  leftHelperFontSize: '--plasma-textfield__leftHelper-font-size',
-  leftHelperFontWeight: '--plasma-textfield__leftHelper-font-weight',
-  leftHelperLetterSpacing: '--plasma-textfield__leftHelper-letter-spacing',
-  leftHelperLineHeight: '--plasma-textfield__leftHelper-line-height',
-  /* Дополнительный цвет который можно использовать в <Icon color="inheit" /> */
-  contentColor: '--plasma-textfield__content-color',
+  labelInnerPadding: '--plasma-textfield-placement_inner__label-padding',
+  contentLabelInnerPadding: '--plasma-textfield-placement_inner__content-padding',
+  leftHelperColor: '--plasma-textfield__left-helper-color',
+  leftHelperColorReadOnly: '--plasma-textfield__left-helper-color-readonly',
+  leftHelperOffset: '--plasma-textfield__left-helper-offset',
+  leftHelperFontFamily: '--plasma-textfield__left-helper-font-family',
+  leftHelperFontStyle: '--plasma-textfield__left-helper-font-style',
+  leftHelperFontSize: '--plasma-textfield__left-helper-font-size',
+  leftHelperFontWeight: '--plasma-textfield__left-helper-font-weight',
+  leftHelperLetterSpacing: '--plasma-textfield__left-helper-letter-spacing',
+  leftHelperLineHeight: '--plasma-textfield__left-helper-line-height',
   /** Прозрачность для всего компонента в состоянии disabled */
-  disabledOpacity: '--plasma-textfield-disabled-opacity'
+  disabledOpacity: '--plasma-textfield-disabled-opacity',
+  /** Токены чипа */
+  chipHeight: '--plasma-textfield__chip-height',
+  chipBorderRadius: '--plasma-textfield__chip-border-radius',
+  chipGap: '--plasma-textfield__chip-gap',
+  chipBackground: '--plasma-textfield__chip-background',
+  chipColor: '--plasma-textfield__chip-color',
+  chipBackgroundHover: '--plasma-textfield__chip-background-hover',
+  chipColorHover: '--plasma-textfield__chip-color-hover',
+  chipScaleHover: '--plasma-textfield__chip-scale-hover',
+  chipBackgroundReadOnly: '--plasma-textfield__chip-background-readonly',
+  chipColorReadOnly: '--plasma-textfield__chip-color-readonly',
+  chipBackgroundReadOnlyHover: '--plasma-textfield__chip-background-readonly-hover',
+  chipColorReadOnlyHover: '--plasma-textfield__chip-color-readonly-hover',
+  chipBackgroundActive: '--plasma-textfield__chip-background-active',
+  chipColorActive: '--plasma-textfield__chip-color-active',
+  chipScaleActive: '--plasma-textfield__chip-scale-active',
+  chipFocusColor: '--plasma-textfield__chip-focus-color',
+  chipCloseIconColor: '--plasma-textfield__chip-close-icon-color',
+  chipOutlineSize: '--plasma-textfield__chip-outline-size',
+  chipWidth: '--plasma-textfield__chip-width',
+  chipPaddingTop: '--plasma-textfield__chip-padding-top',
+  chipPaddingRight: '--plasma-textfield__chip-padding-right',
+  chipPaddingBottom: '--plasma-textfield__chip-padding-bottom',
+  chipPaddingLeft: '--plasma-textfield__chip-padding-left',
+  chipCloseIconSize: '--plasma-textfield__chip-close-icon-size',
+  chipFontFamily: '--plasma-textfield__chip-font-family',
+  chipFontSize: '--plasma-textfield__chip-font-size',
+  chipFontStyle: '--plasma-textfield__chip-font-style',
+  chipFontWeight: '--plasma-textfield__chip-font-weight',
+  chipLetterSpacing: '--plasma-textfield__chip-letter-spacing',
+  chipLineHeight: '--plasma-textfield__chip-line-height',
+  chipClearContentMarginLeft: '--plasma-textfield__chip-clear-content-margin-left',
+  chipClearContentMarginRight: '--plasma-textfield__chip-clear-content-margin-right',
+  chipOpacityReadonly: '--plasma-textfield__chip-opacity-readonly',
+  focusColor: '--plasma-textfield-focus-color'
 };

package/styled-components/es/components/TextField/hooks/index.js

@@ -0,0 +1 @@
+export { useKeyNavigation } from './useKeyNavigation';

package/styled-components/es/components/TextField/hooks/useKeyNavigation.js

@@ -0,0 +1,131 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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; }
+import { useState } from 'react';
+export var Keys = {
+  Enter: 'Enter',
+  Tab: 'Tab',
+  Escape: 'Escape',
+  ArrowLeft: 'ArrowLeft',
+  ArrowRight: 'ArrowRight',
+  Backspace: 'Backspace'
+};
+export var useKeyNavigation = function useKeyNavigation(_ref) {
+  var _ref$controlledRefs = _ref.controlledRefs,
+    chipsRefs = _ref$controlledRefs.chipsRefs,
+    contentRef = _ref$controlledRefs.contentRef,
+    inputRef = _ref$controlledRefs.inputRef,
+    disabled = _ref.disabled,
+    readOnly = _ref.readOnly,
+    chips = _ref.chips,
+    enumerationType = _ref.enumerationType,
+    updateChips = _ref.updateChips,
+    onChange = _ref.onChange,
+    onSearch = _ref.onSearch;
+  var _useState = useState(-1),
+    _useState2 = _slicedToArray(_useState, 2),
+    activeChipIndex = _useState2[0],
+    setActiveChipIndex = _useState2[1];
+  var handleInputKeydown = function handleInputKeydown(event) {
+    var _inputRef$current;
+    var _ref2 = event.target,
+      value = _ref2.value;
+    if (disabled || readOnly) {
+      return;
+    }
+    if (event.key === Keys.Enter && enumerationType === 'chip' && value) {
+      var nextIndex = (chips === null || chips === void 0 ? void 0 : chips.length) || 0;
+      var newChips = [].concat(_toConsumableArray(chips), [{
+        id: "".concat(nextIndex, "_").concat(value),
+        text: value
+      }]);
+      var newValues = newChips.map(function (_ref3) {
+        var text = _ref3.text;
+        return text;
+      });
+      updateChips(newChips, newValues);
+      event.target.value = '';
+      onChange === null || onChange === void 0 ? void 0 : onChange(event);
+    }
+    if (event.key === Keys.Enter && onSearch) {
+      onSearch(value, event);
+    }
+    if (event.key === Keys.Backspace && chips.length && (inputRef === null || inputRef === void 0 ? void 0 : (_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _inputRef$current.selectionStart) === 0) {
+      var _newChips = _toConsumableArray(chips);
+      _newChips === null || _newChips === void 0 ? void 0 : _newChips.pop();
+      chipsRefs === null || chipsRefs === void 0 ? void 0 : chipsRefs.current.pop();
+      var _newValues = _newChips.map(function (_ref4) {
+        var text = _ref4.text;
+        return text;
+      });
+      updateChips(_newChips, _newValues);
+    }
+  };
+  var onChipClear = function onChipClear(clearId) {
+    if (!chips.length) {
+      return;
+    }
+    var newChips = (chips === null || chips === void 0 ? void 0 : chips.filter(function (_ref5) {
+      var chipId = _ref5.id;
+      return chipId !== clearId;
+    })) || [];
+    var newValues = newChips.map(function (_ref6) {
+      var text = _ref6.text;
+      return text;
+    });
+    updateChips(newChips, newValues);
+  };
+  var handleChipKeyDown = function handleChipKeyDown(event, chipId) {
+    if (event.key === Keys.Tab) {
+      event.preventDefault();
+    }
+    if (event.key === Keys.Backspace) {
+      onChipClear(chipId);
+    }
+  };
+  var handleContentKeyDown = function handleContentKeyDown(event) {
+    var _inputRef$current2, _focusedItem, _focusedItem2;
+    var chipsRefsCount = chips.length;
+    var currentCaretPosition = (inputRef === null || inputRef === void 0 ? void 0 : (_inputRef$current2 = inputRef.current) === null || _inputRef$current2 === void 0 ? void 0 : _inputRef$current2.selectionStart) || 0;
+    var newActiveChipIndex = activeChipIndex;
+    var focusedItem = null;
+    if (event.key === Keys.ArrowLeft && enumerationType === 'chip' && currentCaretPosition <= 0) {
+      var _chipsRefs$current;
+      var index = activeChipIndex - 1 <= 0 ? 0 : activeChipIndex - 1;
+      newActiveChipIndex = document.activeElement === (inputRef === null || inputRef === void 0 ? void 0 : inputRef.current) ? chipsRefsCount - 1 : index;
+      focusedItem = (_chipsRefs$current = chipsRefs.current) === null || _chipsRefs$current === void 0 ? void 0 : _chipsRefs$current[newActiveChipIndex];
+    }
+    if (event.key === Keys.ArrowRight && enumerationType === 'chip' && document.activeElement !== (inputRef === null || inputRef === void 0 ? void 0 : inputRef.current)) {
+      var _chipsRefs$current2;
+      var _index = activeChipIndex + 1 >= chipsRefsCount ? activeChipIndex : activeChipIndex + 1;
+      newActiveChipIndex = document.activeElement === (contentRef === null || contentRef === void 0 ? void 0 : contentRef.current) ? 0 : _index;
+      focusedItem = _index === activeChipIndex ? inputRef === null || inputRef === void 0 ? void 0 : inputRef.current : (_chipsRefs$current2 = chipsRefs.current) === null || _chipsRefs$current2 === void 0 ? void 0 : _chipsRefs$current2[newActiveChipIndex];
+    }
+    if (event.key === Keys.Backspace && document.activeElement !== (inputRef === null || inputRef === void 0 ? void 0 : inputRef.current)) {
+      var _chipsRefs$current3;
+      var _index2 = activeChipIndex - 1 <= 0 ? 0 : activeChipIndex - 1;
+      newActiveChipIndex = chipsRefsCount === 0 ? -1 : _index2;
+      focusedItem = chipsRefsCount === 0 ? inputRef === null || inputRef === void 0 ? void 0 : inputRef.current : chipsRefs === null || chipsRefs === void 0 ? void 0 : (_chipsRefs$current3 = chipsRefs.current) === null || _chipsRefs$current3 === void 0 ? void 0 : _chipsRefs$current3[newActiveChipIndex];
+    }
+    (_focusedItem = focusedItem) === null || _focusedItem === void 0 ? void 0 : _focusedItem.focus();
+    (_focusedItem2 = focusedItem) === null || _focusedItem2 === void 0 ? void 0 : _focusedItem2.scrollIntoView({
+      behavior: 'smooth',
+      block: 'center',
+      inline: 'center'
+    });
+    setActiveChipIndex(newActiveChipIndex);
+  };
+  return {
+    handleInputKeydown: handleInputKeydown,
+    handleChipKeyDown: handleChipKeyDown,
+    onChipClear: onChipClear,
+    handleContentKeyDown: handleContentKeyDown
+  };
+};

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

@@ -1,4 +1,4 @@
-export { labelPlacement_inner as textField_labelPlacement_inner } from './_label-placement/inner';
-export { labelPlacement_outer as textField_labelPlacement_outer } from './_label-placement/outer';
+export { labelPlacement_inner as textField_labelPlacement_inner } from './variations/_label-placement/inner';
+export { labelPlacement_outer as textField_labelPlacement_outer } from './variations/_label-placement/outer';
 export { textFieldRoot, textFieldConfig } from './TextField';
 export { tokens as textFieldTokens } from './TextField.tokens';

package/styled-components/es/components/TextField/ui/TextFieldChip/TextFieldChip.js

@@ -0,0 +1,30 @@
+import React, { forwardRef } from 'react';
+import { StyledChip } from './TextFieldChip.styles';
+/**
+ * Чип, отображающий выбранный элемент
+ */
+export var TextFieldChip = /*#__PURE__*/forwardRef(function (_ref, ref) {
+  var chipId = _ref.chipId,
+    text = _ref.text,
+    disabled = _ref.disabled,
+    readOnly = _ref.readOnly,
+    onClick = _ref.onClick,
+    onClear = _ref.onClear,
+    onKeyDown = _ref.onKeyDown;
+  var onClearHandle = function onClearHandle() {
+    return onClear(chipId);
+  };
+  var onKeyDownHandle = function onKeyDownHandle(event) {
+    onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(event, chipId);
+  };
+  return /*#__PURE__*/React.createElement(StyledChip, {
+    ref: ref,
+    tabIndex: -1,
+    disabled: disabled,
+    readOnly: readOnly,
+    onClick: onClick,
+    onClear: onClearHandle,
+    onKeyDown: onKeyDownHandle,
+    text: "".concat(text)
+  });
+});