@salutejs/plasma-new-hope 0.139.0-canary.1406.10688605172.0 → 0.139.0-canary.1418.10685382771.0

package/emotion/es/components/Mask/utils/constants.js

@@ -0,0 +1,24 @@
+export var CharTypes = /*#__PURE__*/function (CharTypes) {
+  CharTypes[CharTypes["USER"] = 1] = "USER";
+  CharTypes[CharTypes["CHAR"] = 2] = "CHAR";
+  CharTypes[CharTypes["MASK"] = 3] = "MASK";
+  return CharTypes;
+}({});
+export var escapeChar = '\\';
+export var defaultFormatChars = [{
+  str: '0',
+  regexp: /[0-9]/
+}, {
+  str: '*',
+  regexp: /./
+}, {
+  str: 'a',
+  regexp: /[a-zA-Z]/
+}, {
+  str: 'я',
+  regexp: /[а-яА-ЯёЁ]/
+}];
+export var KEYBOARD = {
+  BACKSPACE: 8,
+  DELETE: 46
+};

package/emotion/es/components/Mask/utils/createMask.js

@@ -0,0 +1,47 @@
+import { defaultFormatChars } from './constants';
+import { MaskUtils } from './maskUtils';
+import { parseMask } from './parseMask';
+import { removeSelectedRange } from './selection';
+export var defaults = {
+  maskFormat: defaultFormatChars,
+  maskChar: '',
+  showMask: false,
+  removeSelectedRange: removeSelectedRange,
+  showPrefix: false
+};
+export var createMask = function createMask(params) {
+  var _params$mask;
+  var maskString = params.maskString,
+    reformat = params.reformat,
+    _params$showPrefix = params.showPrefix,
+    showPrefix = _params$showPrefix === void 0 ? defaults.showPrefix : _params$showPrefix,
+    _params$maskChar = params.maskChar,
+    maskChar = _params$maskChar === void 0 ? defaults.maskChar : _params$maskChar;
+  var resReformat = reformat;
+  if (!reformat && !params.mask) {
+    resReformat = function resReformat(args) {
+      var str = args.value.map(function (item) {
+        return item["char"];
+      }).join('');
+      return {
+        value: args.value,
+        visibleValue: str,
+        maskedValue: str,
+        selection: args.selection
+      };
+    };
+  } else if (reformat && params.mask) {
+    params.mask = undefined;
+  }
+  if (maskString && maskString.length !== (params === null || params === void 0 || (_params$mask = params.mask) === null || _params$mask === void 0 ? void 0 : _params$mask.length)) {
+    throw new Error('maskString must have same length as mask');
+  }
+  if (maskChar.length > 1) {
+    throw new Error('maskChar must have only 1 char');
+  }
+  var maskUtils = new MaskUtils(showPrefix, maskChar, maskString, resReformat);
+  maskUtils.setMaskFormat = defaults.maskFormat;
+  maskUtils.mask = parseMask(params.mask, maskUtils.maskFormatMap);
+  maskUtils.setValue = params.value;
+  return maskUtils;
+};

package/emotion/es/components/Mask/utils/maskUtils.js

@@ -0,0 +1,250 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { CharTypes } from './constants';
+import { parseMask } from './parseMask';
+import { processInput } from './processInput';
+import { removeSelectedRange } from './selection';
+export var MaskUtils = /*#__PURE__*/function () {
+  function MaskUtils(showPrefix, maskChar, maskString, reformat) {
+    _classCallCheck(this, MaskUtils);
+    _defineProperty(this, "maskFormatMap", void 0);
+    _defineProperty(this, "selection", void 0);
+    _defineProperty(this, "value", void 0);
+    _defineProperty(this, "maskedValue", void 0);
+    _defineProperty(this, "visibleValue", void 0);
+    _defineProperty(this, "mask", void 0);
+    _defineProperty(this, "maskChar", void 0);
+    _defineProperty(this, "maskString", void 0);
+    _defineProperty(this, "showPrefix", void 0);
+    _defineProperty(this, "callbacks", void 0);
+    _defineProperty(this, "reformat", void 0);
+    this.maskFormatMap = {};
+    this.selection = {
+      start: 0,
+      end: 0
+    };
+    this.value = '';
+    this.maskedValue = '';
+    this.visibleValue = '';
+    this.mask = [];
+    this.showPrefix = showPrefix;
+    this.callbacks = [];
+    this.maskChar = maskChar;
+    this.maskString = maskString;
+    this.reformat = reformat;
+  }
+  return _createClass(MaskUtils, [{
+    key: "setShowStartChars",
+    set: function set(show) {
+      this.showPrefix = show;
+    }
+  }, {
+    key: "setMaskFormat",
+    set: function set(maskFormat) {
+      if (!maskFormat) {
+        return;
+      }
+      this.maskFormatMap = maskFormat.reduce(function (acc, current) {
+        acc[String(current.str)] = current;
+        return acc;
+      }, {});
+    }
+  }, {
+    key: "getSelection",
+    get: function get() {
+      var _this$selection = this.selection,
+        start = _this$selection.start,
+        end = _this$selection.end;
+      return {
+        start: start,
+        end: end
+      };
+    }
+  }, {
+    key: "setSelection",
+    set: function set(newSelection) {
+      this.selection = newSelection;
+    }
+  }, {
+    key: "setValue",
+    set: function set(data) {
+      var result;
+      if (this.reformat) {
+        result = this.reformat({
+          value: data,
+          selection: this.selection
+        });
+      } else {
+        var dataList;
+        if (Array.isArray(data)) {
+          dataList = data;
+        } else {
+          dataList = [];
+          for (var i = 0; i < data.length; i++) {
+            dataList.push({
+              "char": data[i],
+              type: CharTypes.USER
+            });
+          }
+        }
+        result = processInput({
+          data: dataList,
+          selection: this.selection,
+          mask: this.mask,
+          maskChar: this.maskChar,
+          maskString: this.maskString,
+          showPrefix: this.showPrefix
+        });
+      }
+      this.applyChanges(result);
+    }
+  }, {
+    key: "getState",
+    value: function getState() {
+      return {
+        value: this.value,
+        maskedValue: this.maskedValue,
+        visibleValue: this.visibleValue,
+        selection: this.selection
+      };
+    }
+  }, {
+    key: "setMask",
+    value: function setMask(newMask) {
+      this.mask = parseMask(newMask, this.maskFormatMap);
+      this.setValue = this.value;
+    }
+  }, {
+    key: "setMaskChar",
+    value: function setMaskChar(newMaskChar) {
+      if (this.maskChar.length > 1) {
+        throw new Error('maskChar must have only 1 char');
+      }
+      this.maskChar = newMaskChar;
+      this.setValue = this.value;
+    }
+  }, {
+    key: "setMaskString",
+    value: function setMaskString(newMaskString) {
+      if (newMaskString && newMaskString.length !== this.mask.length) {
+        throw new Error('maskString must have the same length as mask');
+      }
+      this.maskString = newMaskString;
+      this.setValue = this.value;
+    }
+  }, {
+    key: "setReformat",
+    value: function setReformat(newReformat) {
+      this.reformat = newReformat;
+      this.setValue = this.value;
+    }
+  }, {
+    key: "backspace",
+    value: function backspace() {
+      this.removePreviosOrSelected();
+    }
+  }, {
+    key: "removePreviosOrSelected",
+    value: function removePreviosOrSelected() {
+      var _this$selection2 = this.selection,
+        start = _this$selection2.start,
+        end = _this$selection2.end;
+      if (start === end) {
+        var newStart = end - 1 < 0 ? 0 : end - 1;
+        this.setSelection = {
+          start: newStart,
+          end: end
+        };
+      }
+      this.input('');
+    }
+  }, {
+    key: "removeNextOrSelected",
+    value: function removeNextOrSelected() {
+      var _this$selection3 = this.selection,
+        start = _this$selection3.start,
+        end = _this$selection3.end;
+      if (start === end) {
+        this.setSelection = {
+          start: start,
+          end: end + 1
+        };
+      }
+      this.input('');
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(callback) {
+      this.callbacks.push(callback);
+    }
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe(callback) {
+      this.callbacks = this.callbacks.filter(function (item) {
+        return item !== callback;
+      });
+    }
+  }, {
+    key: "paste",
+    value: function paste(value) {
+      this.input(value);
+    }
+  }, {
+    key: "input",
+    value: function input(_input) {
+      var result;
+      if (this.reformat) {
+        result = this.reformat({
+          value: this.value,
+          input: _input,
+          selection: this.selection
+        });
+      } else {
+        var tmpValue = removeSelectedRange({
+          value: this.value,
+          selection: this.selection,
+          maskChar: this.maskChar,
+          maskString: String(this.maskString)
+        });
+        this.selection.end = this.selection.start;
+        result = processInput({
+          data: tmpValue,
+          input: _input,
+          selection: this.selection,
+          mask: this.mask,
+          maskChar: this.maskChar,
+          maskString: this.maskString,
+          showPrefix: this.showPrefix
+        });
+      }
+      this.applyChanges(result);
+    }
+  }, {
+    key: "applyChanges",
+    value: function applyChanges(result) {
+      var oldMaskedValue = this.maskedValue;
+      var oldVisibleValue = this.visibleValue;
+      var oldSelection = this.selection;
+      this.value = result.value;
+      this.maskedValue = result.maskedValue;
+      this.visibleValue = result.visibleValue;
+      this.setSelection = result.selection;
+      if (oldMaskedValue !== this.maskedValue || oldVisibleValue !== this.visibleValue || oldSelection.start !== this.selection.start || oldSelection.end !== this.selection.end) {
+        this.notify();
+      }
+    }
+  }, {
+    key: "notify",
+    value: function notify() {
+      var state = this.getState();
+      this.callbacks.forEach(function (callback) {
+        callback(state);
+      });
+    }
+  }]);
+}();

package/emotion/es/components/Mask/utils/parseMask.js

@@ -0,0 +1,30 @@
+import { escapeChar } from './constants';
+export var parseMask = function parseMask(mask, format) {
+  if (!mask) {
+    return [];
+  }
+  var stack = [];
+  var escape = false;
+  mask.split('').forEach(function (maskChar) {
+    var item = format === null || format === void 0 ? void 0 : format[maskChar];
+    if (escape && item) {
+      item = undefined;
+      escape = false;
+    }
+    if (!item) {
+      if (!escape && maskChar === escapeChar) {
+        escape = true;
+        return;
+      }
+      escape = false;
+      stack.push({
+        "char": maskChar
+      });
+      return;
+    }
+    if (item.regexp) {
+      stack.push(item);
+    }
+  });
+  return stack;
+};

package/emotion/es/components/Mask/utils/processInput.js

@@ -0,0 +1,46 @@
+import { CharTypes } from './constants';
+import { processMask } from './processMask';
+export var processInput = function processInput(args) {
+  var data = args.data,
+    _args$input = args.input,
+    input = _args$input === void 0 ? '' : _args$input,
+    selection = args.selection,
+    mask = args.mask,
+    _args$maskChar = args.maskChar,
+    maskChar = _args$maskChar === void 0 ? '' : _args$maskChar,
+    _args$maskString = args.maskString,
+    maskString = _args$maskString === void 0 ? '' : _args$maskString,
+    showPrefix = args.showPrefix;
+  var _processMask = processMask(data, mask, input, maskChar, maskString, selection),
+    value = _processMask.value,
+    maskedValue = _processMask.maskedValue,
+    inputValuesApplied = _processMask.inputValuesApplied;
+  var selectionPosition = selection.start + inputValuesApplied;
+  var bound = value.length - 1;
+  var charsCount = 0;
+  while (bound >= 0 && value[bound].type !== CharTypes.USER) {
+    if (value[bound].type === CharTypes.MASK) {
+      charsCount = 0;
+    }
+    if (value[bound].type === CharTypes.CHAR) {
+      charsCount++;
+    }
+    bound--;
+  }
+  if (showPrefix || bound >= 0 || input && input.trim()) {
+    bound += charsCount;
+  }
+  var visibleValue = '';
+  for (var i = 0; i <= bound; i++) {
+    visibleValue += value[i]["char"];
+  }
+  return {
+    value: value,
+    visibleValue: visibleValue,
+    maskedValue: maskedValue,
+    selection: {
+      start: selectionPosition,
+      end: selectionPosition
+    }
+  };
+};

package/emotion/es/components/Mask/utils/processMask.js

@@ -0,0 +1,93 @@
+import { CharTypes } from './constants';
+export var processMask = function processMask(data, mask, input, maskChar, maskString, selection) {
+  var value = [];
+  var valueIndex = 0;
+  var pastedIndex = 0;
+  var maskedValue = '';
+  var inputValuesApplied = 0;
+  function processMaskPartAsChar(maskPart, pastedValuesStack, item) {
+    if (pastedValuesStack && pastedValuesStack[0] === maskPart["char"]) {
+      pastedIndex++;
+    } else if (item && (item["char"] === maskPart["char"] || item.type !== CharTypes.USER) || input) {
+      valueIndex++;
+    }
+    value.push({
+      "char": String(maskPart["char"]),
+      type: CharTypes.CHAR
+    });
+    if (pastedValuesStack) {
+      inputValuesApplied++;
+    }
+    maskedValue += maskPart["char"];
+  }
+  function processMaskPartAsRegExp(maskPart, maskIndex, pastedValuesStack, item) {
+    var _maskPart$regexp2;
+    var part = null;
+    if (pastedValuesStack) {
+      var i = 0;
+      while (!(maskPart !== null && maskPart !== void 0 && (_maskPart$regexp = maskPart.regexp) !== null && _maskPart$regexp !== void 0 && _maskPart$regexp.test(pastedValuesStack[i])) && pastedValuesStack.length > i) {
+        var _maskPart$regexp;
+        i++;
+        pastedIndex++;
+      }
+      if (pastedValuesStack.length > i) {
+        pastedIndex++;
+        inputValuesApplied++;
+        valueIndex++;
+        part = pastedValuesStack[i];
+        value.push({
+          "char": part,
+          type: CharTypes.USER
+        });
+        maskedValue += part;
+      }
+    }
+    if (part) {
+      return;
+    }
+    if (item && item.type === CharTypes.CHAR && data.length > valueIndex + 1) {
+      valueIndex++;
+      processMaskItem(maskPart, maskIndex);
+      return;
+    }
+    if (item && item.type === CharTypes.USER && maskPart !== null && maskPart !== void 0 && (_maskPart$regexp2 = maskPart.regexp) !== null && _maskPart$regexp2 !== void 0 && _maskPart$regexp2.test(item["char"])) {
+      value.push({
+        "char": item["char"],
+        type: CharTypes.USER
+      });
+      maskedValue += item["char"];
+      valueIndex++;
+      return;
+    }
+    part = maskString ? maskString[maskIndex] : maskChar;
+    value.push({
+      "char": part,
+      type: CharTypes.MASK
+    });
+    if (data.length > maskIndex) {
+      valueIndex++;
+    }
+    maskedValue += part;
+  }
+  function processMaskItem(maskPart, maskIndex) {
+    var item = data.length > valueIndex ? data[valueIndex] : null;
+    var pastedValuesStack = '';
+    if (selection.start <= maskIndex && pastedIndex < input.length) {
+      pastedValuesStack = input.slice(pastedIndex);
+    }
+    if (maskPart["char"]) {
+      return processMaskPartAsChar(maskPart, pastedValuesStack, item);
+    }
+    if (maskPart.regexp) {
+      return processMaskPartAsRegExp(maskPart, maskIndex, pastedValuesStack, item);
+    }
+  }
+  mask.forEach(function (maskPart, maskIndex) {
+    processMaskItem(maskPart, maskIndex);
+  });
+  return {
+    value: value,
+    maskedValue: maskedValue,
+    inputValuesApplied: inputValuesApplied
+  };
+};

package/emotion/es/components/Mask/utils/selection.js

@@ -0,0 +1,42 @@
+import { CharTypes } from './constants';
+var copyMaskChar = function copyMaskChar(count, maskChar) {
+  var res = [];
+  for (var i = 0; i < count; i++) {
+    res.push({
+      "char": maskChar,
+      type: CharTypes.MASK
+    });
+  }
+  return res;
+};
+var pasteMaskSymbols = function pasteMaskSymbols(maskString, maskChar, selection) {
+  if (maskString) {
+    var res = [];
+    for (var i = selection.start; i < selection.end; i++) {
+      res.push({
+        "char": maskString[i],
+        type: CharTypes.MASK
+      });
+    }
+    return res;
+  }
+  return copyMaskChar(selection.end - selection.start, maskChar);
+};
+export var removeSelectedRange = function removeSelectedRange(args) {
+  var value = args.value,
+    selection = args.selection,
+    maskChar = args.maskChar,
+    maskString = args.maskString;
+  if (selection.end < selection.start) {
+    var tmp = selection.end;
+    selection.end = selection.start;
+    selection.start = tmp;
+  }
+  if (selection.start === selection.end) {
+    return value;
+  }
+  if (value.length > selection.start) {
+    return value.slice(0, selection.start).concat(pasteMaskSymbols(maskString, maskChar, selection), value.slice(selection.end, value.length));
+  }
+  return value;
+};

package/emotion/es/components/Select/Select.js

@@ -1,4 +1,4 @@
-var _excluded = ["value", "onChange", "target", "items", "placement", "label", "labelPlacement", "placeholder", "helperText", "disabled", "view", "size", "listOverflow", "listHeight", "listWidth", "contentLeft", "onScrollBottom", "chipView", "variant", "portal", "renderValue", "renderItem", "status", "onItemSelect", "separator", "closeAfterSelect"];
+var _excluded = ["value", "onChange", "target", "items", "placement", "label", "labelPlacement", "placeholder", "helperText", "disabled", "view", "size", "listOverflow", "listHeight", "listWidth", "contentLeft", "onScrollBottom", "chipView", "variant", "portal", "renderValue", "renderItem", "status", "onItemSelect", "separator"];
 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."); }
@@ -56,7 +56,6 @@ export var selectRoot = function selectRoot(Root) {
       status = props.status,
       onItemSelect = props.onItemSelect,
       separator = props.separator,
-      outerCloseAfterSelect = props.closeAfterSelect,
       rest = _objectWithoutProperties(props, _excluded);
     var _useState = useState(outerValue || props.multiselect ? [] : ''),
       _useState2 = _slicedToArray(_useState, 2),
@@ -94,7 +93,6 @@ export var selectRoot = function selectRoot(Root) {
       _useState4 = _slicedToArray(_useState3, 2),
       checked = _useState4[0],
       setChecked = _useState4[1];
-    var closeAfterSelect = outerCloseAfterSelect !== null && outerCloseAfterSelect !== void 0 ? outerCloseAfterSelect : !props.multiselect;
     var targetRef = useOutsideClick(function () {
       if (focusedChipIndex != null) {
         dispatchFocusedChipIndex({
@@ -136,14 +134,6 @@ export var selectRoot = function selectRoot(Root) {
             newValues.push(item.value);
           }
         });
-        if (closeAfterSelect) {
-          dispatchPath({
-            type: 'reset'
-          });
-          dispatchFocusedPath({
-            type: 'reset'
-          });
-        }
         if (onChange) {
           onChange(newValues);
         }
@@ -168,14 +158,6 @@ export var selectRoot = function selectRoot(Root) {
           checkedCopy.set(item.value, 'done');
           updateSingleAncestors(item, checkedCopy, 'dot');
         }
-        if (closeAfterSelect) {
-          dispatchPath({
-            type: 'reset'
-          });
-          dispatchFocusedPath({
-            type: 'reset'
-          });
-        }
         if (onChange) {
           onChange(isCurrentChecked ? '' : item.value);
         }

package/emotion/es/components/Select/ui/InfiniteLoader/InfiniteLoader.js

@@ -0,0 +1,11 @@
+import React from 'react';
+import { classes } from '../../Select.tokens';
+import { StyledSpinner, Wrapper } from './InfiniteLoader.styles';
+export var InfiniteLoader = function InfiniteLoader(_ref) {
+  var variant = _ref.variant;
+  return /*#__PURE__*/React.createElement(Wrapper, {
+    variant: variant
+  }, /*#__PURE__*/React.createElement(StyledSpinner, {
+    className: classes.selectSpinner
+  }), "\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430");
+};

package/emotion/es/components/Select/ui/InfiniteLoader/InfiniteLoader.styles.js

@@ -0,0 +1,19 @@
+import _styled from "@emotion/styled/base";
+import { tokens, classes } from '../../Select.tokens';
+import { component } from '../../../../engines';
+import { spinnerConfig, spinnerTokens } from '../../../Spinner';
+var Spinner = /*#__PURE__*/component(spinnerConfig);
+export var StyledSpinner = /*#__PURE__*/_styled(Spinner, {
+  target: "eyro8r01",
+  label: "plasma-new-hope__StyledSpinner"
+})(spinnerTokens.color, ":var(--text-primary);", spinnerTokens.size, ":var(", tokens.spinnerSize, ");" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+export var Wrapper = /*#__PURE__*/_styled("div", {
+  target: "eyro8r00",
+  label: "plasma-new-hope__Wrapper"
+})("display:flex;align-items:center;justify-content:center;gap:0.25rem;height:var(", tokens.itemHeight, ");padding:", function (_ref) {
+  var variant = _ref.variant;
+  return "var(".concat(variant === 'tight' ? tokens.itemPaddingTight : tokens.itemPadding, ")");
+}, ";font-family:var(", tokens.fontFamily, ");font-size:var(", tokens.fontSize, ");font-style:var(", tokens.fontStyle, ");font-weight:var(", tokens.fontWeight, ");letter-spacing:var(", tokens.fontLetterSpacing, ");line-height:var(", tokens.fontLineHeight, ");user-select:none;& .", classes.selectSpinner, "{", spinnerTokens.size, ":", function (_ref2) {
+  var variant = _ref2.variant;
+  return "var(".concat(variant === 'tight' ? tokens.spinnerSizeTight : tokens.spinnerSize, ")");
+}, ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));

package/emotion/es/components/Select/ui/Target/ui/Textfield/Textfield.js

@@ -87,10 +87,7 @@ export var Textfield = function Textfield(_ref2) {
     renderTarget: Boolean(selectProps.renderTarget)
   }, /*#__PURE__*/React.createElement(Wrapper, null, selectProps !== null && selectProps !== void 0 && selectProps.renderTarget ? selectProps.renderTarget(Array.isArray(value) ? value.map(function (value) {
     return valueToItemMap.get(value);
-  }) : valueToItemMap.get(value)) : /*#__PURE__*/React.createElement(React.Fragment, null, contentLeft && (!selectProps.multiselect || isEmpty(value)) && /*#__PURE__*/React.createElement(ContentLeftWrapper, null, contentLeft), /*#__PURE__*/React.createElement(ChipWrapper, {
-    multiselect: selectProps.multiselect,
-    value: value
-  }, getLabel({
+  }) : valueToItemMap.get(value)) : /*#__PURE__*/React.createElement(React.Fragment, null, contentLeft && (!selectProps.multiselect || isEmpty(value)) && /*#__PURE__*/React.createElement(ContentLeftWrapper, null, contentLeft), /*#__PURE__*/React.createElement(ChipWrapper, null, getLabel({
     value: value,
     valueToItemMap: valueToItemMap,
     onChipClick: onChipClick,