text: 'use strict';
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var _extends = _interopDefault(require('@babel/runtime/helpers/extends'));
  var _classCallCheck = _interopDefault(require('@babel/runtime/helpers/classCallCheck'));
  var _createClass = _interopDefault(require('@babel/runtime/helpers/createClass'));
  var _inherits = _interopDefault(require('@babel/runtime/helpers/inherits'));
  var _possibleConstructorReturn = _interopDefault(require('@babel/runtime/helpers/possibleConstructorReturn'));
  var _getPrototypeOf = _interopDefault(require('@babel/runtime/helpers/getPrototypeOf'));
  var React = require('react');
  var React__default = _interopDefault(React);
  var _objectWithoutProperties = _interopDefault(require('@babel/runtime/helpers/objectWithoutProperties'));
  
  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(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 { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
  var defaultProps = {
    defaultInputValue: '',
    defaultMenuIsOpen: false,
    defaultValue: null
  };
  
  var manageState = function manageState(SelectComponent) {
    var _class, _temp;
  
    return _temp = _class = /*#__PURE__*/function (_Component) {
      _inherits(StateManager, _Component);
  
      var _super = _createSuper(StateManager);
  
      function StateManager() {
        var _this;
  
        _classCallCheck(this, StateManager);
  
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
  
        _this = _super.call.apply(_super, [this].concat(args));
        _this.select = void 0;
        _this.state = {
          inputValue: _this.props.inputValue !== undefined ? _this.props.inputValue : _this.props.defaultInputValue,
          menuIsOpen: _this.props.menuIsOpen !== undefined ? _this.props.menuIsOpen : _this.props.defaultMenuIsOpen,
          value: _this.props.value !== undefined ? _this.props.value : _this.props.defaultValue
        };
  
        _this.onChange = function (value, actionMeta) {
          _this.callProp('onChange', value, actionMeta);
  
          _this.setState({
            value: value
          });
        };
  
        _this.onInputChange = function (value, actionMeta) {
          // TODO: for backwards compatibility, we allow the prop to return a new
          // value, but now inputValue is a controllable prop we probably shouldn't
          var newValue = _this.callProp('onInputChange', value, actionMeta);
  
          _this.setState({
            inputValue: newValue !== undefined ? newValue : value
          });
        };
  
        _this.onMenuOpen = function () {
          _this.callProp('onMenuOpen');
  
          _this.setState({
            menuIsOpen: true
          });
        };
  
        _this.onMenuClose = function () {
          _this.callProp('onMenuClose');
  
          _this.setState({
            menuIsOpen: false
          });
        };
  
        return _this;
      }
  
      _createClass(StateManager, [{
        key: "focus",
        value: function focus() {
          this.select.focus();
        }
      }, {
        key: "blur",
        value: function blur() {
          this.select.blur();
        } // FIXME: untyped flow code, return any
  
      }, {
        key: "getProp",
        value: function getProp(key) {
          return this.props[key] !== undefined ? this.props[key] : this.state[key];
        } // FIXME: untyped flow code, return any
  
      }, {
        key: "callProp",
        value: function callProp(name) {
          if (typeof this.props[name] === 'function') {
            var _this$props;
  
            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
              args[_key2 - 1] = arguments[_key2];
            }
  
            return (_this$props = this.props)[name].apply(_this$props, args);
          }
        }
      }, {
        key: "render",
        value: function render() {
          var _this2 = this;
  
          var _this$props2 = this.props,
              defaultInputValue = _this$props2.defaultInputValue,
              defaultMenuIsOpen = _this$props2.defaultMenuIsOpen,
              defaultValue = _this$props2.defaultValue,
              props = _objectWithoutProperties(_this$props2, ["defaultInputValue", "defaultMenuIsOpen", "defaultValue"]);
  
          return /*#__PURE__*/React__default.createElement(SelectComponent, _extends({}, props, {
            ref: function ref(_ref) {
              _this2.select = _ref;
            },
            inputValue: this.getProp('inputValue'),
            menuIsOpen: this.getProp('menuIsOpen'),
            onChange: this.onChange,
            onInputChange: this.onInputChange,
            onMenuClose: this.onMenuClose,
            onMenuOpen: this.onMenuOpen,
            value: this.getProp('value')
          }));
        }
      }]);
  
      return StateManager;
    }(React.Component), _class.defaultProps = defaultProps, _temp;
  };
  
  exports.manageState = manageState;
  