@i-novus/n2o-components 1.0.0

package/lib/inputs/Select/Select.js

@@ -0,0 +1,705 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Select = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactOnclickoutside = _interopRequireDefault(require("react-onclickoutside"));
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _first = _interopRequireDefault(require("lodash/first"));
+
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+
+var _find = _interopRequireDefault(require("lodash/find"));
+
+var _reactstrap = require("reactstrap");
+
+var _InputSelectGroup = require("../InputSelect/InputSelectGroup");
+
+var _PopupList = require("../InputSelect/PopupList");
+
+var _utils = require("./utils");
+
+var _Popup = require("./Popup");
+
+var _SelectInput = require("./SelectInput");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+/**
+ * N2OSelect
+ * @reactProps {boolean} loading - флаг анимации загрузки
+ * @reactProps {array} options - данные
+ * @reactProps {string} valueFieldId - значение ключа value в данных
+ * @reactProps {string} labelFieldId - значение ключа label в данных
+ * @reactProps {string} iconFieldId - поле для иконки
+ * @reactProps {string} imageFieldId - поле для картинки
+ * @reactProps {string} statusFieldId - поле для статуса
+ * @reactProps {object} badge - данные для баджа
+ * @reactProps {boolean} disabled - флаг неактивности
+ * @reactProps {array} disabledValues - неактивные данные
+ * @reactProps {string} enabledFieldId - поле для активности
+ * @reactProps {string} filter - варианты фильтрации
+ * @reactProps {string} value - текущее значение
+ * @reactProps {function} onInput - callback при вводе в инпут
+ * @reactProps {function} onChange - callback при выборе значения или вводе
+ * @reactProps {string} placeHolder - подсказка в инпуте
+ * @reactProps {boolean} resetOnBlur - фича, при которой сбрасывается значение контрола, если оно не выбрано из popup
+ * @reactProps {function} onClose - callback на закрытие попапа
+ * @reactProps {string} groupFieldId - поле для группировки
+ * @reactProps {boolean} closePopupOnSelect - флаг закрытия попапа при выборе
+ * @reactProps {boolean} hasCheckboxes - флаг наличия чекбоксов
+ * @reactProps {string} format - формат
+ * @reactProps {boolean} searchByTap - поиск по нажатию кнопки
+ */
+var selectType = {
+  SINGLE: 'single',
+  CHECKBOXES: 'checkboxes'
+};
+
+function getSelected(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+
+  if (!(0, _isEmpty["default"])(value)) {
+    return [value];
+  }
+
+  return [];
+}
+
+var SelectComponent = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2["default"])(SelectComponent, _React$Component);
+
+  var _super = _createSuper(SelectComponent);
+
+  function SelectComponent(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, SelectComponent);
+    _this = _super.call(this, props);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "control", null);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleDataSearch", function (input, delay, callback) {
+      var _this$props = _this.props,
+          onSearch = _this$props.onSearch,
+          filter = _this$props.filter,
+          options = _this$props.options,
+          labelFieldId = _this$props.labelFieldId;
+
+      if (filter) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var filterFunc = function filterFunc(item) {
+          return String.prototype[filter].call(item, input);
+        };
+
+        var filteredOptions = options.filter(function (item) {
+          return filterFunc(item[labelFieldId].toString());
+        });
+
+        _this.setState({
+          options: filteredOptions
+        });
+      } else {
+        onSearch(input, delay === false ? delay : true, callback);
+      }
+    });
+    var _this$props2 = _this.props,
+        value = _this$props2.value,
+        _options = _this$props2.options,
+        type = _this$props2.type;
+    _this.state = {
+      value: '',
+      isExpanded: false,
+      options: _options,
+      selected: getSelected(value),
+      hasCheckboxes: type === selectType.CHECKBOXES
+    };
+    _this.control = null;
+    _this.n2oSelectRef = /*#__PURE__*/(0, _react.createRef)();
+    _this.handleButtonClick = _this.handleButtonClick.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.handleInputChange = _this.handleInputChange.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.handleInputFocus = _this.handleInputFocus.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.hideOptionsList = _this.hideOptionsList.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.handleItemSelect = _this.handleItemSelect.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.removeSelectedItem = _this.removeSelectedItem.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.clearSelected = _this.clearSelected.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.handleSearchButton = _this.handleSearchButton.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.handleOnBlur = _this.handleOnBlur.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.setControlRef = _this.setControlRef.bind((0, _assertThisInitialized2["default"])(_this));
+    return _this;
+  }
+
+  (0, _createClass2["default"])(SelectComponent, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this$props3 = this.props,
+          initial = _this$props3.initial,
+          options = _this$props3.options,
+          valueFieldId = _this$props3.valueFieldId;
+
+      if (Array.isArray(initial)) {
+        this.setStateFromInitial(initial, options, valueFieldId);
+      }
+    } // eslint-disable-next-line react/no-deprecated
+
+  }, {
+    key: "componentWillReceiveProps",
+    value: function componentWillReceiveProps(nextProps) {
+      var options = this.props.options;
+      var state = {};
+
+      if (!(0, _isEqual["default"])(options, nextProps.options)) {
+        state.options = nextProps.options;
+      }
+
+      this.setState(state);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var _this$props4 = this.props,
+          initial = _this$props4.initial,
+          options = _this$props4.options,
+          valueFieldId = _this$props4.valueFieldId,
+          value = _this$props4.value;
+
+      if (Array.isArray(initial) && !(0, _isEqual["default"])(initial, prevProps.initial)) {
+        this.setStateFromInitial(initial, options, valueFieldId);
+        return;
+      }
+
+      if (!(0, _isEqual["default"])(value, prevProps.value)) {
+        this.setState({
+          selected: getSelected(value)
+        });
+      }
+    }
+    /**
+     * Хак для мапинга айдишников, которые берутся из адресной строки в виде строк, но ожидается число
+     * TODO удалить после того, как починится поведение парсинга адресной строки будет опираться на указанные типы
+     * @param {Array.<object>} [initial]
+     * @param options
+     * @param {String} valueFieldId
+     * @private
+     */
+
+  }, {
+    key: "setStateFromInitial",
+    value: function setStateFromInitial(initial, options, valueFieldId) {
+      var mapOptions = function mapOptions(options) {
+        var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'string';
+        return options.map(function (option) {
+          return _objectSpread(_objectSpread({}, option), (0, _defineProperty2["default"])({}, valueFieldId, type === 'number' ? Number(option[valueFieldId]) : String(option[valueFieldId])));
+        });
+      };
+
+      if ((0, _isEmpty["default"])(options)) {
+        this.setState({
+          selected: mapOptions(initial)
+        });
+      } else {
+        var selected = options.filter(function (option) {
+          var idType = (0, _typeof2["default"])(option[valueFieldId]);
+          return (0, _find["default"])(mapOptions(initial, idType), option);
+        });
+        this.setState({
+          selected: selected
+        });
+      }
+    }
+    /**
+     * Удаляет элемент из списка выбранных
+     * @param item - элемент
+     * @private
+     */
+
+  }, {
+    key: "removeSelectedItem",
+    value: function removeSelectedItem(item) {
+      var _this$props5 = this.props,
+          valueFieldId = _this$props5.valueFieldId,
+          onChange = _this$props5.onChange;
+      var stateSelected = this.state.selected;
+      var selected = typeof stateSelected !== 'string' ? stateSelected.filter(function (i) {
+        return i[valueFieldId] !== item[valueFieldId];
+      }) : stateSelected;
+      this.setState({
+        selected: selected
+      });
+
+      if (onChange) {
+        onChange(selected);
+      }
+    }
+    /**
+     * Изменение видимости попапа
+     * @param newIsExpanded - новое значение видимости
+     * @private
+     */
+
+  }, {
+    key: "changePopUpVision",
+    value: function changePopUpVision(newIsExpanded) {
+      var _this$props6 = this.props,
+          fetchData = _this$props6.fetchData,
+          onClose = _this$props6.onClose;
+      var isExpanded = this.state.isExpanded;
+
+      if (isExpanded === newIsExpanded) {
+        return;
+      }
+
+      var onOpen = fetchData({
+        page: 1
+      });
+      this.setState({
+        isExpanded: newIsExpanded
+      }, newIsExpanded ? onOpen : onClose);
+    }
+    /**
+     * Обрабатывает нажатие на кнопку
+     * @private
+     */
+
+  }, {
+    key: "handleButtonClick",
+    value: function handleButtonClick() {
+      var disabled = this.props.disabled;
+      var isExpanded = this.state.isExpanded;
+
+      if (!disabled) {
+        this.changePopUpVision(!isExpanded);
+      }
+    }
+    /**
+     * Обрабатывает форкус на инпуте
+     * @private
+     */
+
+  }, {
+    key: "handleInputFocus",
+    value: function handleInputFocus() {
+      this.changePopUpVision(true);
+    }
+    /**
+     * Скрывает popUp
+     * @private
+     */
+
+  }, {
+    key: "hideOptionsList",
+    value: function hideOptionsList() {
+      this.changePopUpVision(false);
+    }
+    /**
+     * Уставнавливает новое значение инпута
+     * @param newValue - новое значение
+     * @private
+     */
+
+  }, {
+    key: "setNewValue",
+    value: function setNewValue(newValue) {
+      this.setState({
+        value: newValue
+      });
+    }
+    /**
+     * Удаляет выбранные элементы
+     * @private
+     */
+
+  }, {
+    key: "clearSelected",
+    value: function clearSelected(e) {
+      e.stopPropagation();
+      e.preventDefault();
+      var _this$props7 = this.props,
+          disabled = _this$props7.disabled,
+          onChange = _this$props7.onChange,
+          onBlur = _this$props7.onBlur;
+
+      if (disabled) {
+        return;
+      }
+
+      this.setState({
+        selected: []
+      });
+      onChange(null);
+      onBlur(null);
+    }
+    /**
+     * Выполняет поиск элементов для popUp, если установлен фильтр
+     * @param input - значение для поиска
+     * @param {boolean} delay
+     * @param {Function} callback
+     * @private
+     */
+
+  }, {
+    key: "insertSelected",
+    value:
+    /**
+     * Устанавливает выбранный элемент
+     * @param item - элемент массива options
+     * @private
+     */
+    function insertSelected(item) {
+      var _this$props8 = this.props,
+          onChange = _this$props8.onChange,
+          onBlur = _this$props8.onBlur;
+      var _this$state = this.state,
+          stateSelected = _this$state.selected,
+          hasCheckboxes = _this$state.hasCheckboxes;
+      var selected = [item];
+      var value = item;
+
+      if (hasCheckboxes) {
+        selected = [].concat((0, _toConsumableArray2["default"])(stateSelected || []), [item]);
+        value = selected;
+      }
+
+      this.setState({
+        selected: selected
+      });
+
+      if (onChange) {
+        onChange(value);
+        onBlur(value);
+      }
+    }
+    /**
+     * Обрабатывает изменение инпута
+     * @param newValue - новое значение
+     * @private
+     */
+
+  }, {
+    key: "handleInputChange",
+    value: function handleInputChange(newValue) {
+      var _this$props9 = this.props,
+          searchByTap = _this$props9.searchByTap,
+          onChange = _this$props9.onChange,
+          onInput = _this$props9.onInput,
+          resetOnBlur = _this$props9.resetOnBlur;
+      this.setNewValue(newValue);
+
+      if (!searchByTap) {
+        this.handleDataSearch(newValue);
+      }
+
+      if (!resetOnBlur) {
+        onChange(newValue);
+      }
+
+      onInput(newValue);
+    }
+    /**
+     * Обрабатывает поиск по нажатию
+     * @private
+     */
+
+  }, {
+    key: "handleSearchButton",
+    value: function handleSearchButton() {
+      var value = this.state.value;
+      this.handleDataSearch(value);
+    }
+    /**
+     * Очищает инпут и результаты поиска
+     * @private
+     */
+
+  }, {
+    key: "clearSearchField",
+    value: function clearSearchField() {
+      var options = this.props.options;
+      this.setState({
+        value: '',
+        options: options
+      });
+    }
+    /**
+     * Обрабатывает выбор элемента из popUp
+     * @param item - элемент массива options
+     * @private
+     */
+
+  }, {
+    key: "handleItemSelect",
+    value: function handleItemSelect(item) {
+      var closePopupOnSelect = this.props.closePopupOnSelect;
+      this.insertSelected(item);
+
+      if (closePopupOnSelect) {
+        this.hideOptionsList();
+      }
+
+      this.clearSearchField();
+
+      if (this.control) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.control.focus();
+      }
+    }
+    /**
+     * Обрабатывает поведение инпута при потери фокуса, если есть resetOnBlur
+     * @private
+     */
+
+  }, {
+    key: "handleResetOnBlur",
+    value: function handleResetOnBlur() {
+      var selected = this.state.selected;
+      var _this$props10 = this.props,
+          resetOnBlur = _this$props10.resetOnBlur,
+          options = _this$props10.options;
+
+      if (resetOnBlur && !selected) {
+        this.setState({
+          value: '',
+          options: options
+        });
+      }
+    }
+    /**
+     * Обрабатывает клик за пределы компонента
+     * вызывается библиотекой react-onclickoutside
+     */
+
+  }, {
+    key: "handleClickOutside",
+    value: function handleClickOutside() {
+      var _this$props11 = this.props,
+          onBlur = _this$props11.onBlur,
+          value = _this$props11.value;
+      var isExpanded = this.state.isExpanded;
+
+      if (isExpanded) {
+        this.hideOptionsList();
+        onBlur(value);
+      }
+    }
+  }, {
+    key: "handleOnBlur",
+    value: function handleOnBlur(e) {
+      e.preventDefault();
+      this.handleResetOnBlur();
+    }
+  }, {
+    key: "setControlRef",
+    value: function setControlRef(el) {
+      this.control = el;
+    }
+  }, {
+    key: "renderPlaceholder",
+    value: function renderPlaceholder() {
+      var _this$props12 = this.props,
+          _this$props12$selectF = _this$props12.selectFormat,
+          selectFormat = _this$props12$selectF === void 0 ? 'Объектов {size} шт' : _this$props12$selectF,
+          _this$props12$selectF2 = _this$props12.selectFormatOne,
+          selectFormatOne = _this$props12$selectF2 === void 0 ? '' : _this$props12$selectF2,
+          _this$props12$selectF3 = _this$props12.selectFormatFew,
+          selectFormatFew = _this$props12$selectF3 === void 0 ? '' : _this$props12$selectF3,
+          _this$props12$selectF4 = _this$props12.selectFormatMany,
+          selectFormatMany = _this$props12$selectF4 === void 0 ? '' : _this$props12$selectF4;
+      var _this$state2 = this.state,
+          selected = _this$state2.selected,
+          hasCheckboxes = _this$state2.hasCheckboxes;
+      var selectedCount = selected.length;
+      var text;
+
+      if (!(0, _isEmpty["default"])(selectFormatOne) && !(0, _isEmpty["default"])(selectFormatFew) && !(0, _isEmpty["default"])(selectFormatMany) && selectedCount >= 1 && hasCheckboxes) {
+        text = (0, _utils.getNoun)(selectedCount, selectFormatOne, selectFormatFew, selectFormatMany).replace('{size}', "".concat(selectedCount));
+      } else if (selectedCount >= 1 && hasCheckboxes) {
+        text = selectFormat.replace('{size}', "".concat(selectedCount));
+      } else {
+        text = null;
+      }
+
+      return text;
+    }
+  }, {
+    key: "renderValue",
+    value: function renderValue() {
+      var _this$props13 = this.props,
+          labelFieldId = _this$props13.labelFieldId,
+          _this$props13$placeho = _this$props13.placeholder,
+          placeholder = _this$props13$placeho === void 0 ? '' : _this$props13$placeho;
+      var selected = this.state.selected;
+
+      if ((0, _isEmpty["default"])(selected)) {
+        return placeholder;
+      }
+
+      var _selected = (0, _slicedToArray2["default"])(selected, 1),
+          selectedElement = _selected[0];
+
+      return (0, _get["default"])(selectedElement, labelFieldId);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props14 = this.props,
+          loading = _this$props14.loading,
+          className = _this$props14.className,
+          valueFieldId = _this$props14.valueFieldId,
+          labelFieldId = _this$props14.labelFieldId,
+          iconFieldId = _this$props14.iconFieldId,
+          disabled = _this$props14.disabled,
+          disabledValues = _this$props14.disabledValues,
+          enabledFieldId = _this$props14.enabledFieldId,
+          imageFieldId = _this$props14.imageFieldId,
+          statusFieldId = _this$props14.statusFieldId,
+          groupFieldId = _this$props14.groupFieldId,
+          descriptionFieldId = _this$props14.descriptionFieldId,
+          format = _this$props14.format,
+          placeholder = _this$props14.placeholder,
+          badge = _this$props14.badge,
+          fetchData = _this$props14.fetchData,
+          page = _this$props14.page,
+          hasSearch = _this$props14.hasSearch,
+          cleanable = _this$props14.cleanable,
+          style = _this$props14.style;
+
+      var inputSelectStyle = _objectSpread({
+        width: '100%'
+      }, style);
+
+      var _this$state3 = this.state,
+          selected = _this$state3.selected,
+          isExpanded = _this$state3.isExpanded,
+          hasCheckboxes = _this$state3.hasCheckboxes,
+          value = _this$state3.value,
+          options = _this$state3.options;
+      var title = (0, _get["default"])((0, _first["default"])(selected), "".concat(labelFieldId));
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        className: "n2o-input-select",
+        title: title,
+        style: inputSelectStyle,
+        onBlur: this.handleOnBlur,
+        ref: this.n2oSelectRef
+      }, /*#__PURE__*/_react["default"].createElement(_reactstrap.Button, {
+        innerRef: this.setControlRef,
+        onClick: this.handleButtonClick
+      }, /*#__PURE__*/_react["default"].createElement(_InputSelectGroup.InputSelectGroup, {
+        className: className,
+        isExpanded: isExpanded,
+        loading: loading,
+        disabled: disabled,
+        iconFieldId: iconFieldId,
+        imageFieldId: imageFieldId,
+        cleanable: cleanable,
+        selected: selected,
+        onClearClick: this.clearSelected
+      }, /*#__PURE__*/_react["default"].createElement("span", {
+        className: "valueText"
+      }, hasCheckboxes ? this.renderPlaceholder() : this.renderValue()))), /*#__PURE__*/_react["default"].createElement(_Popup.Popup, {
+        isExpanded: isExpanded,
+        inputSelect: this.n2oSelectRef.current
+      }, /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, hasSearch && /*#__PURE__*/_react["default"].createElement(_SelectInput.N2OSelectInput, {
+        placeholder: placeholder || '',
+        onChange: this.handleInputChange,
+        onSearch: this.handleSearchButton,
+        value: value
+      }), /*#__PURE__*/_react["default"].createElement(_PopupList.PopupList, {
+        options: options,
+        valueFieldId: valueFieldId,
+        labelFieldId: labelFieldId,
+        iconFieldId: iconFieldId,
+        imageFieldId: imageFieldId,
+        statusFieldId: statusFieldId,
+        badge: badge,
+        descriptionFieldId: descriptionFieldId,
+        enabledFieldId: enabledFieldId,
+        onSelect: this.handleItemSelect,
+        fetchData: fetchData,
+        page: page,
+        isExpanded: isExpanded,
+        selected: selected,
+        disabledValues: disabledValues,
+        groupFieldId: groupFieldId,
+        hasCheckboxes: hasCheckboxes,
+        onRemoveItem: this.removeSelectedItem,
+        format: format,
+        loading: loading
+      }))));
+    }
+  }]);
+  return SelectComponent;
+}(_react["default"].Component);
+
+(0, _defineProperty2["default"])(SelectComponent, "defaultProps", {
+  cleanable: true,
+  valueFieldId: 'id',
+  labelFieldId: 'name',
+  iconFieldId: 'icon',
+  loading: false,
+  disabled: false,
+  disabledValues: [],
+  resetOnBlur: false,
+  searchByTap: false,
+  hasSearch: false,
+  options: [],
+  value: {},
+  descriptionFieldId: '',
+  enabledFieldId: '',
+  statusFieldId: '',
+  groupFieldId: '',
+  imageFieldId: '',
+  closePopupOnSelect: true,
+  onSearch: function onSearch() {},
+  onChange: function onChange() {},
+  fetchData: function fetchData() {
+    return function () {};
+  },
+  onInput: function onInput() {},
+  onClose: function onClose() {},
+  onBlur: function onBlur() {}
+});
+var Select = (0, _reactOnclickoutside["default"])(SelectComponent);
+exports.Select = Select;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/inputs/Select/Select.tsx"],"names":["selectType","SINGLE","CHECKBOXES","getSelected","value","Array","isArray","SelectComponent","props","input","delay","callback","onSearch","filter","options","labelFieldId","filterFunc","item","String","prototype","call","filteredOptions","toString","setState","type","state","isExpanded","selected","hasCheckboxes","control","n2oSelectRef","handleButtonClick","bind","handleInputChange","handleInputFocus","hideOptionsList","handleItemSelect","removeSelectedItem","clearSelected","handleSearchButton","handleOnBlur","setControlRef","initial","valueFieldId","setStateFromInitial","nextProps","prevProps","mapOptions","map","option","Number","idType","onChange","stateSelected","i","newIsExpanded","fetchData","onClose","onOpen","page","disabled","changePopUpVision","newValue","e","stopPropagation","preventDefault","onBlur","searchByTap","onInput","resetOnBlur","setNewValue","handleDataSearch","closePopupOnSelect","insertSelected","clearSearchField","focus","handleResetOnBlur","el","selectFormat","selectFormatOne","selectFormatFew","selectFormatMany","selectedCount","length","text","replace","placeholder","selectedElement","loading","className","iconFieldId","disabledValues","enabledFieldId","imageFieldId","statusFieldId","groupFieldId","descriptionFieldId","format","badge","hasSearch","cleanable","style","inputSelectStyle","width","title","renderPlaceholder","renderValue","current","React","Component","Select"],"mappings":"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","sourcesContent":["import React, { FocusEvent, RefObject, createRef } from 'react'\nimport onClickOutside from 'react-onclickoutside'\nimport isEqual from 'lodash/isEqual'\nimport get from 'lodash/get'\nimport first from 'lodash/first'\nimport isEmpty from 'lodash/isEmpty'\nimport find from 'lodash/find'\nimport { Button } from 'reactstrap'\n\nimport { InputSelectGroup } from '../InputSelect/InputSelectGroup'\nimport { Filter, TOption } from '../InputSelect/types'\nimport { BadgeType, PopupList } from '../InputSelect/PopupList'\n\nimport { getNoun } from './utils'\nimport { Popup } from './Popup'\nimport { N2OSelectInput } from './SelectInput'\n\n/**\n * N2OSelect\n * @reactProps {boolean} loading - флаг анимации загрузки\n * @reactProps {array} options - данные\n * @reactProps {string} valueFieldId - значение ключа value в данных\n * @reactProps {string} labelFieldId - значение ключа label в данных\n * @reactProps {string} iconFieldId - поле для иконки\n * @reactProps {string} imageFieldId - поле для картинки\n * @reactProps {string} statusFieldId - поле для статуса\n * @reactProps {object} badge - данные для баджа\n * @reactProps {boolean} disabled - флаг неактивности\n * @reactProps {array} disabledValues - неактивные данные\n * @reactProps {string} enabledFieldId - поле для активности\n * @reactProps {string} filter - варианты фильтрации\n * @reactProps {string} value - текущее значение\n * @reactProps {function} onInput - callback при вводе в инпут\n * @reactProps {function} onChange - callback при выборе значения или вводе\n * @reactProps {string} placeHolder - подсказка в инпуте\n * @reactProps {boolean} resetOnBlur - фича, при которой сбрасывается значение контрола, если оно не выбрано из popup\n * @reactProps {function} onClose - callback на закрытие попапа\n * @reactProps {string} groupFieldId - поле для группировки\n * @reactProps {boolean} closePopupOnSelect - флаг закрытия попапа при выборе\n * @reactProps {boolean} hasCheckboxes - флаг наличия чекбоксов\n * @reactProps {string} format - формат\n * @reactProps {boolean} searchByTap - поиск по нажатию кнопки\n */\n\nconst selectType = {\n    SINGLE: 'single',\n    CHECKBOXES: 'checkboxes',\n}\n\ntype State = {\n    hasCheckboxes: boolean,\n    input?: string\n    isExpanded: boolean,\n    options?: TOption[],\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    selected: any[]\n    value: string\n}\n\nfunction getSelected(value: Props['value']) {\n    if (Array.isArray(value)) {\n        return value\n    }\n    if (!isEmpty(value)) {\n        return [value]\n    }\n\n    return []\n}\n\nclass SelectComponent extends React.Component<Props, State> {\n    private control: null | HTMLButtonElement = null\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    n2oSelectRef: RefObject<any>\n\n    constructor(props: Props) {\n        super(props)\n        const { value, options, type } = this.props\n\n        this.state = {\n            value: '',\n            isExpanded: false,\n            options,\n            selected: getSelected(value),\n            hasCheckboxes: type === selectType.CHECKBOXES,\n        }\n\n        this.control = null\n        this.n2oSelectRef = createRef()\n\n        this.handleButtonClick = this.handleButtonClick.bind(this)\n        this.handleInputChange = this.handleInputChange.bind(this)\n        this.handleInputFocus = this.handleInputFocus.bind(this)\n        this.hideOptionsList = this.hideOptionsList.bind(this)\n        this.handleItemSelect = this.handleItemSelect.bind(this)\n        this.removeSelectedItem = this.removeSelectedItem.bind(this)\n        this.clearSelected = this.clearSelected.bind(this)\n        this.handleSearchButton = this.handleSearchButton.bind(this)\n        this.handleOnBlur = this.handleOnBlur.bind(this)\n        this.setControlRef = this.setControlRef.bind(this)\n    }\n\n    componentDidMount() {\n        const { initial, options, valueFieldId } = this.props\n\n        if (Array.isArray(initial)) {\n            this.setStateFromInitial(initial, options, valueFieldId)\n        }\n    }\n\n    // eslint-disable-next-line react/no-deprecated\n    componentWillReceiveProps(nextProps: Props) {\n        const { options } = this.props\n        const state = {} as State\n\n        if (!isEqual(options, nextProps.options)) {\n            state.options = nextProps.options\n        }\n        this.setState(state)\n    }\n\n    componentDidUpdate(prevProps: Props) {\n        const { initial, options, valueFieldId, value } = this.props\n\n        if (Array.isArray(initial) && !isEqual(initial, prevProps.initial)) {\n            this.setStateFromInitial(initial, options, valueFieldId)\n\n            return\n        }\n        if (!isEqual(value, prevProps.value)) {\n            this.setState({\n                selected: getSelected(value),\n            })\n        }\n    }\n\n    /**\n     * Хак для мапинга айдишников, которые берутся из адресной строки в виде строк, но ожидается число\n     * TODO удалить после того, как починится поведение парсинга адресной строки будет опираться на указанные типы\n     * @param {Array.<object>} [initial]\n     * @param options\n     * @param {String} valueFieldId\n     * @private\n     */\n    setStateFromInitial(initial: Props['options'], options: Props['options'], valueFieldId: Props['valueFieldId']) {\n        const mapOptions = (options: Props['options'], type = 'string') => options.map(option => ({\n            ...option,\n            ...{\n                [valueFieldId]:\n                    type === 'number'\n                        ? Number(option[valueFieldId as keyof TOption])\n                        : String(option[valueFieldId as keyof TOption]),\n            },\n        }))\n\n        if (isEmpty(options)) {\n            this.setState({\n                selected: mapOptions(initial),\n            })\n        } else {\n            const selected = options.filter((option) => {\n                const idType = typeof option[valueFieldId as keyof TOption]\n\n                return find(mapOptions(initial, idType), option)\n            })\n\n            this.setState({\n                selected,\n            })\n        }\n    }\n\n    /**\n     * Удаляет элемент из списка выбранных\n     * @param item - элемент\n     * @private\n     */\n    removeSelectedItem(item: TOption) {\n        const { valueFieldId, onChange } = this.props\n        const { selected: stateSelected } = this.state\n        const selected = typeof stateSelected !== 'string' ? stateSelected.filter(\n            i => i[valueFieldId] !== item[valueFieldId as keyof TOption],\n        ) : stateSelected\n\n        this.setState({\n            selected,\n        })\n        if (onChange) {\n            onChange(selected)\n        }\n    }\n\n    /**\n     * Изменение видимости попапа\n     * @param newIsExpanded - новое значение видимости\n     * @private\n     */\n    changePopUpVision(newIsExpanded: State['isExpanded']) {\n        const { fetchData, onClose } = this.props\n        const { isExpanded } = this.state\n\n        if (isExpanded === newIsExpanded) { return }\n\n        const onOpen = fetchData({ page: 1 })\n\n        this.setState(\n            {\n                isExpanded: newIsExpanded,\n            },\n            newIsExpanded ? onOpen : onClose,\n        )\n    }\n\n    /**\n     * Обрабатывает нажатие на кнопку\n     * @private\n     */\n    handleButtonClick() {\n        const { disabled } = this.props\n        const { isExpanded } = this.state\n\n        if (!disabled) {\n            this.changePopUpVision(!isExpanded)\n        }\n    }\n\n    /**\n     * Обрабатывает форкус на инпуте\n     * @private\n     */\n    handleInputFocus() {\n        this.changePopUpVision(true)\n    }\n\n    /**\n     * Скрывает popUp\n     * @private\n     */\n    hideOptionsList() {\n        this.changePopUpVision(false)\n    }\n\n    /**\n     * Уставнавливает новое значение инпута\n     * @param newValue - новое значение\n     * @private\n     */\n    setNewValue(newValue: State['value']) {\n        this.setState({\n            value: newValue,\n        })\n    }\n\n    /**\n     * Удаляет выбранные элементы\n     * @private\n     */\n    clearSelected(e: Event) {\n        e.stopPropagation()\n        e.preventDefault()\n\n        const { disabled, onChange, onBlur } = this.props\n\n        if (disabled) {\n            return\n        }\n\n        this.setState({\n            selected: [],\n        })\n        onChange(null)\n        onBlur(null)\n    }\n\n    /**\n     * Выполняет поиск элементов для popUp, если установлен фильтр\n     * @param input - значение для поиска\n     * @param {boolean} delay\n     * @param {Function} callback\n     * @private\n     */\n    handleDataSearch: Props['onSearch'] = (input, delay, callback) => {\n        const { onSearch, filter, options, labelFieldId } = this.props\n\n        if (filter) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            const filterFunc = (item: TOption) => (String.prototype[filter as any] as any).call(item, input)\n            const filteredOptions = options.filter(item => filterFunc(item[labelFieldId as keyof TOption].toString()))\n\n            this.setState({ options: filteredOptions })\n        } else {\n            onSearch(input, delay === false ? delay : true, callback)\n        }\n    }\n\n    /**\n     * Устанавливает выбранный элемент\n     * @param item - элемент массива options\n     * @private\n     */\n    insertSelected(item: TOption) {\n        const { onChange, onBlur } = this.props\n        const { selected: stateSelected, hasCheckboxes } = this.state\n        let selected = [item]\n        let value: TOption | TOption[] = item\n\n        if (hasCheckboxes) {\n            selected = [...(stateSelected || []), item]\n            value = selected\n        }\n\n        this.setState({\n            selected,\n        })\n\n        if (onChange) {\n            onChange(value)\n            onBlur(value)\n        }\n    }\n\n    /**\n     * Обрабатывает изменение инпута\n     * @param newValue - новое значение\n     * @private\n     */\n    handleInputChange(newValue: string) {\n        const { searchByTap, onChange, onInput, resetOnBlur } = this.props\n\n        this.setNewValue(newValue)\n\n        if (!searchByTap) {\n            this.handleDataSearch(newValue)\n        }\n        if (!resetOnBlur) {\n            onChange(newValue)\n        }\n        onInput(newValue)\n    }\n\n    /**\n     * Обрабатывает поиск по нажатию\n     * @private\n     */\n    handleSearchButton() {\n        const { value } = this.state\n\n        this.handleDataSearch(value)\n    }\n\n    /**\n     * Очищает инпут и результаты поиска\n     * @private\n     */\n    clearSearchField() {\n        const { options } = this.props\n\n        this.setState({\n            value: '',\n            options,\n        })\n    }\n\n    /**\n     * Обрабатывает выбор элемента из popUp\n     * @param item - элемент массива options\n     * @private\n     */\n    handleItemSelect(item: TOption) {\n        const { closePopupOnSelect } = this.props\n\n        this.insertSelected(item)\n\n        if (closePopupOnSelect) {\n            this.hideOptionsList()\n        }\n\n        this.clearSearchField()\n\n        if (this.control) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            (this.control as any).focus()\n        }\n    }\n\n    /**\n     * Обрабатывает поведение инпута при потери фокуса, если есть resetOnBlur\n     * @private\n     */\n    handleResetOnBlur() {\n        const { selected } = this.state\n        const { resetOnBlur, options } = this.props\n\n        if (resetOnBlur && !selected) {\n            this.setState({\n                value: '',\n                options,\n            })\n        }\n    }\n\n    /**\n     * Обрабатывает клик за пределы компонента\n     * вызывается библиотекой react-onclickoutside\n     */\n    handleClickOutside() {\n        const { onBlur, value } = this.props\n        const { isExpanded } = this.state\n\n        if (isExpanded) {\n            this.hideOptionsList()\n            onBlur(value)\n        }\n    }\n\n    handleOnBlur(e: FocusEvent<HTMLDivElement>) {\n        e.preventDefault()\n        this.handleResetOnBlur()\n    }\n\n    setControlRef(el: HTMLButtonElement) {\n        this.control = el\n    }\n\n    renderPlaceholder() {\n        const {\n            selectFormat = 'Объектов {size} шт',\n            selectFormatOne = '',\n            selectFormatFew = '',\n            selectFormatMany = '',\n        } = this.props\n\n        const { selected, hasCheckboxes } = this.state\n        const selectedCount = selected.length\n        let text\n\n        if (\n            !isEmpty(selectFormatOne) &&\n            !isEmpty(selectFormatFew) &&\n            !isEmpty(selectFormatMany) &&\n            selectedCount >= 1 &&\n            hasCheckboxes\n        ) {\n            text = getNoun(\n                selectedCount,\n                selectFormatOne,\n                selectFormatFew,\n                selectFormatMany,\n            ).replace('{size}', `${selectedCount}`)\n        } else if (selectedCount >= 1 && hasCheckboxes) {\n            text = selectFormat.replace('{size}', `${selectedCount}`)\n        } else {\n            text = null\n        }\n\n        return text\n    }\n\n    renderValue() {\n        const { labelFieldId, placeholder = '' } = this.props\n        const { selected } = this.state\n\n        if (isEmpty(selected)) {\n            return placeholder\n        }\n\n        const [selectedElement] = selected\n\n        return get(selectedElement, labelFieldId)\n    }\n\n    render() {\n        const {\n            loading,\n            className,\n            valueFieldId,\n            labelFieldId,\n            iconFieldId,\n            disabled,\n            disabledValues,\n            enabledFieldId,\n            imageFieldId,\n            statusFieldId,\n            groupFieldId,\n            descriptionFieldId,\n            format,\n            placeholder,\n            badge,\n            fetchData,\n            page,\n            hasSearch,\n            cleanable,\n            style,\n        } = this.props\n        const inputSelectStyle = { width: '100%', ...style }\n\n        const { selected, isExpanded, hasCheckboxes, value, options } = this.state\n\n        const title = get(first(selected), `${labelFieldId}`)\n\n        return (\n            <div\n                className=\"n2o-input-select\"\n                title={title}\n                style={inputSelectStyle}\n                onBlur={this.handleOnBlur}\n                ref={this.n2oSelectRef}\n            >\n                <Button innerRef={this.setControlRef} onClick={this.handleButtonClick}>\n                    <InputSelectGroup\n                        className={className}\n                        isExpanded={isExpanded}\n                        loading={loading}\n                        disabled={disabled}\n                        iconFieldId={iconFieldId}\n                        imageFieldId={imageFieldId}\n                        cleanable={cleanable}\n                        selected={selected}\n                        onClearClick={this.clearSelected}\n                    >\n                        <span className=\"valueText\">\n                            {\n                                hasCheckboxes\n                                    ? this.renderPlaceholder()\n                                    : this.renderValue()\n                            }\n                        </span>\n                    </InputSelectGroup>\n                </Button>\n                <Popup isExpanded={isExpanded} inputSelect={this.n2oSelectRef.current}>\n                    <>\n                        {hasSearch && (\n                            <N2OSelectInput\n                                placeholder={placeholder || ''}\n                                onChange={this.handleInputChange}\n                                onSearch={this.handleSearchButton}\n                                value={value}\n                            />\n                        )}\n                        <PopupList\n                            options={options}\n                            valueFieldId={valueFieldId}\n                            labelFieldId={labelFieldId}\n                            iconFieldId={iconFieldId}\n                            imageFieldId={imageFieldId}\n                            statusFieldId={statusFieldId}\n                            badge={badge}\n                            descriptionFieldId={descriptionFieldId}\n                            enabledFieldId={enabledFieldId}\n                            onSelect={this.handleItemSelect}\n                            fetchData={fetchData}\n                            page={page}\n                            isExpanded={isExpanded}\n                            selected={selected}\n                            disabledValues={disabledValues}\n                            groupFieldId={groupFieldId}\n                            hasCheckboxes={hasCheckboxes}\n                            onRemoveItem={this.removeSelectedItem}\n                            format={format}\n                            loading={loading}\n                        />\n                    </>\n                </Popup>\n            </div>\n        )\n    }\n\n    static defaultProps = {\n        cleanable: true,\n        valueFieldId: 'id',\n        labelFieldId: 'name',\n        iconFieldId: 'icon',\n        loading: false,\n        disabled: false,\n        disabledValues: [],\n        resetOnBlur: false,\n        searchByTap: false,\n        hasSearch: false,\n        options: [],\n        value: {},\n        descriptionFieldId: '',\n        enabledFieldId: '',\n        statusFieldId: '',\n        groupFieldId: '',\n        imageFieldId: '',\n        closePopupOnSelect: true,\n        onSearch() {},\n        onChange() {},\n        fetchData: () => () => {},\n        onInput() {},\n        onClose() {},\n        onBlur() {},\n    } as Props\n}\n\ntype Props = {\n    /**\n     * Данные для badge\n     */\n    badge?: BadgeType,\n    className?: string,\n    cleanable: boolean,\n    closePopupOnSelect: boolean,\n    descriptionFieldId: string,\n    /**\n     * Флаг активности\n     */\n    disabled: boolean,\n    /**\n     * Неактивные данные\n     */\n    disabledValues: [],\n    /**\n     * Ключ enabled в данных\n     */\n    enabledFieldId: string,\n    fetchData(arg: object): () => void,\n    /**\n     * Фильтрация\n     */\n    filter?: Filter,\n    /**\n     * Формат\n     */\n    format?: string,\n    groupFieldId: string,\n    /**\n     * Флаг наличия поиска\n     */\n    hasSearch: boolean,\n    /**\n     * Ключ icon в данных\n     */\n    iconFieldId: string,\n    /**\n     * Ключ image в данных\n     */\n    imageFieldId: string,\n    initial?: string | number,\n    /**\n     * Ключ label в данных\n     */\n    labelFieldId: string,\n    /**\n     * Флаг загрузки\n     */\n    loading: boolean,\n    onBlur(arg: Props['value']): void,\n    /**\n     * Callback на изменение\n     */\n    onChange(arg: TOption | TOption[] | null | string): void,\n    /**\n     * Callback на закрытие попапа\n     */\n    onClose(): void,\n    /**\n     * Callback при вводе в инпут\n     */\n    onInput(input: string): void,\n    /**\n     * Callback на поиск\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    onSearch(input: State['input'], delay?: boolean, callback?: any): void,\n    /**\n     * Данные\n     */\n    options: TOption[],\n    page?: number,\n    /**\n     * Placeholder контрола\n     */\n    placeholder?: string,\n    /**\n     * Сброс значения при потере фокуса\n     */\n    resetOnBlur: boolean,\n    /**\n     * Поиск по нажатию кнопки\n     */\n    searchByTap: boolean,\n    selectFormat?: string,\n    selectFormatFew?: string,\n    selectFormatMany?: string,\n    selectFormatOne?: string,\n    /**\n     * Ключ image в данных\n     */\n    statusFieldId: string,\n    style?: object,\n    type?: string,\n    /**\n     * Значение\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    value: any,\n    /**\n     * Ключ id в данных\n     */\n    valueFieldId: string\n}\n\nexport const Select = onClickOutside(SelectComponent)\n"]}