text: "use strict";
  
  var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.hasValue = hasValue;
  exports.isFilled = isFilled;
  exports.isAdornedStart = isAdornedStart;
  exports.default = exports.styles = void 0;
  
  var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
  
  var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
  
  var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
  
  var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
  
  var _getPrototypeOf = _interopRequireDefault(require("@babel/runtime/core-js/object/get-prototype-of"));
  
  var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
  
  var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
  
  var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
  
  var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
  
  var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
  
  var _react = _interopRequireDefault(require("react"));
  
  var _propTypes = _interopRequireDefault(require("prop-types"));
  
  var _classnames = _interopRequireDefault(require("classnames"));
  
  var _withStyles = _interopRequireDefault(require("../styles/withStyles"));
  
  var _Textarea = _interopRequireDefault(require("./Textarea"));
  
  // Supports determination of isControlled().
  // Controlled input accepts its current value as a prop.
  //
  // @see https://facebook.github.io/react/docs/forms.html#controlled-components
  // @param value
  // @returns {boolean} true if string (including '') or number (including zero)
  function hasValue(value) {
    return value != null && !(Array.isArray(value) && value.length === 0);
  } // Determine if field is empty or filled.
  // Response determines if label is presented above field or as placeholder.
  //
  // @param obj
  // @param SSR
  // @returns {boolean} False when not present or empty string.
  //                    True when any number or string with length.
  
  
  function isFilled(obj) {
    var SSR = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    return obj && (hasValue(obj.value) && obj.value !== '' || SSR && hasValue(obj.defaultValue) && obj.defaultValue !== '');
  } // Determine if an Input is adorned on start.
  // It's corresponding to the left with LTR.
  //
  // @param obj
  // @returns {boolean} False when no adornments.
  //                    True when adorned at the start.
  
  
  function isAdornedStart(obj) {
    return obj.startAdornment;
  }
  
  var styles = function styles(theme) {
    var light = theme.palette.type === 'light';
    var placeholder = {
      color: 'currentColor',
      opacity: light ? 0.42 : 0.5,
      transition: theme.transitions.create('opacity', {
        duration: theme.transitions.duration.shorter
      })
    };
    var placeholderHidden = {
      opacity: 0
    };
    var placeholderVisible = {
      opacity: light ? 0.42 : 0.5
    };
    var bottomLineColor = light ? 'rgba(0, 0, 0, 0.42)' : 'rgba(255, 255, 255, 0.7)';
    return {
      root: {
        // Mimics the default input display property used by browsers for an input.
        display: 'inline-flex',
        position: 'relative',
        fontFamily: theme.typography.fontFamily,
        color: light ? 'rgba(0, 0, 0, 0.87)' : theme.palette.common.white,
        fontSize: theme.typography.pxToRem(16),
        lineHeight: '1.1875em',
        // Reset (19px), match the native input line-height
        '&$disabled': {
          color: theme.palette.text.disabled
        }
      },
      formControl: {
        'label + &': {
          marginTop: theme.spacing.unit * 2
        }
      },
      focused: {},
      disabled: {},
      underline: {
        '&:after': {
          borderBottom: "2px solid ".concat(theme.palette.primary[light ? 'dark' : 'light']),
          left: 0,
          bottom: 0,
          // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
          content: '""',
          position: 'absolute',
          right: 0,
          transform: 'scaleX(0)',
          transition: theme.transitions.create('transform', {
            duration: theme.transitions.duration.shorter,
            easing: theme.transitions.easing.easeOut
          }),
          pointerEvents: 'none' // Transparent to the hover style.
  
        },
        '&$focused:after': {
          transform: 'scaleX(1)'
        },
        '&$error:after': {
          borderBottomColor: theme.palette.error.main,
          transform: 'scaleX(1)' // error is always underlined in red
  
        },
        '&:before': {
          borderBottom: "1px solid ".concat(bottomLineColor),
          left: 0,
          bottom: 0,
          // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
          content: '"need text here to prevent subpixel zoom issue"',
          color: 'transparent',
          position: 'absolute',
          right: 0,
          transition: theme.transitions.create('border-bottom-color', {
            duration: theme.transitions.duration.shorter
          }),
          pointerEvents: 'none' // Transparent to the hover style.
  
        },
        '&:hover:not($disabled):not($focused):not($error):before': {
          borderBottom: "2px solid ".concat(theme.palette.text.primary)
        },
        '&$disabled:before': {
          borderBottom: "1px dotted ".concat(bottomLineColor)
        }
      },
      error: {},
      multiline: {
        padding: "".concat(theme.spacing.unit - 2, "px 0 ").concat(theme.spacing.unit - 1, "px")
      },
      fullWidth: {
        width: '100%'
      },
      input: {
        font: 'inherit',
        color: 'currentColor',
        padding: "".concat(theme.spacing.unit - 2, "px 0 ").concat(theme.spacing.unit - 1, "px"),
        border: 0,
        boxSizing: 'content-box',
        verticalAlign: 'middle',
        background: 'none',
        margin: 0,
        // Reset for Safari
        // Remove grey highlight
        WebkitTapHighlightColor: 'transparent',
        display: 'block',
        // Make the flex item shrink with Firefox
        minWidth: 0,
        flexGrow: 1,
        '&::-webkit-input-placeholder': placeholder,
        '&::-moz-placeholder': placeholder,
        // Firefox 19+
        '&:-ms-input-placeholder': placeholder,
        // IE 11
        '&::-ms-input-placeholder': placeholder,
        // Edge
        '&:focus': {
          outline: 0
        },
        // Reset Firefox invalid required input style
        '&:invalid': {
          boxShadow: 'none'
        },
        '&::-webkit-search-decoration': {
          // Remove the padding when type=search.
          '-webkit-appearance': 'none'
        },
        // Show and hide the placeholder logic
        'label[data-shrink=false] + $formControl &': {
          '&::-webkit-input-placeholder': placeholderHidden,
          '&::-moz-placeholder': placeholderHidden,
          // Firefox 19+
          '&:-ms-input-placeholder': placeholderHidden,
          // IE 11
          '&::-ms-input-placeholder': placeholderHidden,
          // Edge
          '&:focus::-webkit-input-placeholder': placeholderVisible,
          '&:focus::-moz-placeholder': placeholderVisible,
          // Firefox 19+
          '&:focus:-ms-input-placeholder': placeholderVisible,
          // IE 11
          '&:focus::-ms-input-placeholder': placeholderVisible // Edge
  
        },
        '&$disabled': {
          opacity: 1 // Reset iOS opacity
  
        }
      },
      inputMarginDense: {
        paddingTop: theme.spacing.unit / 2 - 1
      },
      inputMultiline: {
        resize: 'none',
        padding: 0
      },
      inputType: {
        // type="date" or type="time", etc. have specific styles we need to reset.
        height: '1.1875em' // Reset (19px), match the native input line-height
  
      },
      inputTypeSearch: {
        // Improve type search style.
        '-moz-appearance': 'textfield',
        '-webkit-appearance': 'textfield'
      }
    };
  };
  
  exports.styles = styles;
  
  function formControlState(props, context) {
    var disabled = props.disabled;
    var error = props.error;
    var margin = props.margin;
  
    if (context && context.muiFormControl) {
      if (typeof disabled === 'undefined') {
        disabled = context.muiFormControl.disabled;
      }
  
      if (typeof error === 'undefined') {
        error = context.muiFormControl.error;
      }
  
      if (typeof margin === 'undefined') {
        margin = context.muiFormControl.margin;
      }
    }
  
    return {
      disabled: disabled,
      error: error,
      margin: margin
    };
  }
  
  var Input =
  /*#__PURE__*/
  function (_React$Component) {
    (0, _inherits2.default)(Input, _React$Component);
  
    function Input(props, context) {
      var _this;
  
      (0, _classCallCheck2.default)(this, Input);
      _this = (0, _possibleConstructorReturn2.default)(this, (Input.__proto__ || (0, _getPrototypeOf.default)(Input)).call(this, props, context));
      Object.defineProperty((0, _assertThisInitialized2.default)(_this), "state", {
        configurable: true,
        enumerable: true,
        writable: true,
        value: {
          focused: false
        }
      });
      Object.defineProperty((0, _assertThisInitialized2.default)(_this), "isControlled", {
        configurable: true,
        enumerable: true,
        writable: true,
        value: _this.props.value != null
      });
      Object.defineProperty((0, _assertThisInitialized2.default)(_this), "input", {
        configurable: true,
        enumerable: true,
        writable: true,
        value: null
      });
      Object.defineProperty((0, _assertThisInitialized2.default)(_this), "handleFocus", {
        configurable: true,
        enumerable: true,
        writable: true,
        value: function value(event) {
          // Fix an bug with IE11 where the focus/blur events are triggered
          // while the input is disabled.
          if (formControlState(_this.props, _this.context).disabled) {
            event.stopPropagation();
            return;
          }
  
          _this.setState({
            focused: true
          });
  
          if (_this.props.onFocus) {
            _this.props.onFocus(event);
          }
        }
      });
      Object.defineProperty((0, _assertThisInitialized2.default)(_this), "handleBlur", {
        configurable: true,
        enumerable: true,
        writable: true,
        value: function value(event) {
          _this.setState({
            focused: false
          });
  
          if (_this.props.onBlur) {
            _this.props.onBlur(event);
          }
        }
      });
      Object.defineProperty((0, _assertThisInitialized2.default)(_this), "handleChange", {
        configurable: true,
        enumerable: true,
        writable: true,
        value: function value(event) {
          if (!_this.isControlled) {
            _this.checkDirty(_this.input);
          } // Perform in the willUpdate
  
  
          if (_this.props.onChange) {
            _this.props.onChange(event);
          }
        }
      });
      Object.defineProperty((0, _assertThisInitialized2.default)(_this), "handleRefInput", {
        configurable: true,
        enumerable: true,
        writable: true,
        value: function value(node) {
          _this.input = node;
  
          if (_this.props.inputRef) {
            _this.props.inputRef(node);
          } else if (_this.props.inputProps && _this.props.inputProps.ref) {
            _this.props.inputProps.ref(node);
          }
        }
      });
  
      if (_this.isControlled) {
        _this.checkDirty(props);
      }
  
      var componentWillReceiveProps = function componentWillReceiveProps(nextProps, nextContext) {
        // The blur won't fire when the disabled state is set on a focused input.
        // We need to book keep the focused state manually.
        if (!formControlState(_this.props, _this.context).disabled && formControlState(nextProps, nextContext).disabled) {
          _this.setState({
            focused: false
          });
        }
      };
  
      var componentWillUpdate = function componentWillUpdate(nextProps, nextState, nextContext) {
        // Book keep the focused state.
        if (!formControlState(_this.props, _this.context).disabled && formControlState(nextProps, nextContext).disabled) {
          var muiFormControl = _this.context.muiFormControl;
  
          if (muiFormControl && muiFormControl.onBlur) {
            muiFormControl.onBlur();
          }
        }
      }; // Support for react >= 16.3.0 && < 17.0.0
  
      /* istanbul ignore else */
  
  
      if (_react.default.createContext) {
        _this.UNSAFE_componentWillReceiveProps = componentWillReceiveProps;
        _this.UNSAFE_componentWillUpdate = componentWillUpdate;
      } else {
        _this.componentWillReceiveProps = componentWillReceiveProps;
        _this.componentWillUpdate = componentWillUpdate;
      }
  
      return _this;
    }
  
    (0, _createClass2.default)(Input, [{
      key: "getChildContext",
      value: function getChildContext() {
        // We are consuming the parent muiFormControl context.
        // We don't want a child to consume it a second time.
        return {
          muiFormControl: null
        };
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        if (!this.isControlled) {
          this.checkDirty(this.input);
        }
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        if (this.isControlled) {
          this.checkDirty(this.props);
        } // else performed in the onChange
  
      }
    }, {
      key: "checkDirty",
      value: function checkDirty(obj) {
        var muiFormControl = this.context.muiFormControl;
  
        if (isFilled(obj)) {
          if (muiFormControl && muiFormControl.onFilled) {
            muiFormControl.onFilled();
          }
  
          if (this.props.onFilled) {
            this.props.onFilled();
          }
  
          return;
        }
  
        if (muiFormControl && muiFormControl.onEmpty) {
          muiFormControl.onEmpty();
        }
  
        if (this.props.onEmpty) {
          this.props.onEmpty();
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _classNames, _classNames2;
  
        var _props = this.props,
            autoComplete = _props.autoComplete,
            autoFocus = _props.autoFocus,
            classes = _props.classes,
            classNameProp = _props.className,
            defaultValue = _props.defaultValue,
            disabledProp = _props.disabled,
            disableUnderline = _props.disableUnderline,
            endAdornment = _props.endAdornment,
            errorProp = _props.error,
            fullWidth = _props.fullWidth,
            id = _props.id,
            inputComponent = _props.inputComponent,
            _props$inputProps = _props.inputProps;
        _props$inputProps = _props$inputProps === void 0 ? {} : _props$inputProps;
        var inputPropsClassName = _props$inputProps.className,
            inputPropsProp = (0, _objectWithoutProperties2.default)(_props$inputProps, ["className"]),
            inputRef = _props.inputRef,
            marginProp = _props.margin,
            multiline = _props.multiline,
            name = _props.name,
            onBlur = _props.onBlur,
            onChange = _props.onChange,
            onEmpty = _props.onEmpty,
            onFilled = _props.onFilled,
            onFocus = _props.onFocus,
            onKeyDown = _props.onKeyDown,
            onKeyUp = _props.onKeyUp,
            placeholder = _props.placeholder,
            readOnly = _props.readOnly,
            rows = _props.rows,
            rowsMax = _props.rowsMax,
            startAdornment = _props.startAdornment,
            type = _props.type,
            value = _props.value,
            other = (0, _objectWithoutProperties2.default)(_props, ["autoComplete", "autoFocus", "classes", "className", "defaultValue", "disabled", "disableUnderline", "endAdornment", "error", "fullWidth", "id", "inputComponent", "inputProps", "inputRef", "margin", "multiline", "name", "onBlur", "onChange", "onEmpty", "onFilled", "onFocus", "onKeyDown", "onKeyUp", "placeholder", "readOnly", "rows", "rowsMax", "startAdornment", "type", "value"]);
        var muiFormControl = this.context.muiFormControl;
  
        var _formControlState = formControlState(this.props, this.context),
            disabled = _formControlState.disabled,
            error = _formControlState.error,
            margin = _formControlState.margin;
  
        var className = (0, _classnames.default)(classes.root, (_classNames = {}, (0, _defineProperty2.default)(_classNames, classes.disabled, disabled), (0, _defineProperty2.default)(_classNames, classes.error, error), (0, _defineProperty2.default)(_classNames, classes.fullWidth, fullWidth), (0, _defineProperty2.default)(_classNames, classes.focused, this.state.focused), (0, _defineProperty2.default)(_classNames, classes.formControl, muiFormControl), (0, _defineProperty2.default)(_classNames, classes.multiline, multiline), (0, _defineProperty2.default)(_classNames, classes.underline, !disableUnderline), _classNames), classNameProp);
        var inputClassName = (0, _classnames.default)(classes.input, (_classNames2 = {}, (0, _defineProperty2.default)(_classNames2, classes.disabled, disabled), (0, _defineProperty2.default)(_classNames2, classes.inputType, type !== 'text'), (0, _defineProperty2.default)(_classNames2, classes.inputTypeSearch, type === 'search'), (0, _defineProperty2.default)(_classNames2, classes.inputMultiline, multiline), (0, _defineProperty2.default)(_classNames2, classes.inputMarginDense, margin === 'dense'), _classNames2), inputPropsClassName);
        var required = muiFormControl && muiFormControl.required === true;
        var InputComponent = 'input';
        var inputProps = (0, _objectSpread2.default)({}, inputPropsProp, {
          ref: this.handleRefInput
        });
  
        if (inputComponent) {
          InputComponent = inputComponent;
          inputProps = (0, _objectSpread2.default)({
            // Rename ref to inputRef as we don't know the
            // provided `inputComponent` structure.
            inputRef: this.handleRefInput
          }, inputProps, {
            ref: null
          });
        } else if (multiline) {
          if (rows && !rowsMax) {
            InputComponent = 'textarea';
          } else {
            inputProps = (0, _objectSpread2.default)({
              rowsMax: rowsMax,
              textareaRef: this.handleRefInput
            }, inputProps, {
              ref: null
            });
            InputComponent = _Textarea.default;
          }
        }
  
        return _react.default.createElement("div", (0, _extends2.default)({
          className: className
        }, other), startAdornment, _react.default.createElement(InputComponent, (0, _extends2.default)({
          "aria-invalid": error,
          "aria-required": required,
          autoComplete: autoComplete,
          autoFocus: autoFocus,
          className: inputClassName,
          defaultValue: defaultValue,
          disabled: disabled,
          id: id,
          name: name,
          onBlur: this.handleBlur,
          onChange: this.handleChange,
          onFocus: this.handleFocus,
          onKeyDown: onKeyDown,
          onKeyUp: onKeyUp,
          placeholder: placeholder,
          readOnly: readOnly,
          required: required ? true : undefined,
          rows: rows,
          type: type,
          value: value
        }, inputProps)), endAdornment);
      }
    }]);
    return Input;
  }(_react.default.Component);
  
  Input.propTypes = process.env.NODE_ENV !== "production" ? {
    /**
     * This property helps users to fill forms faster, especially on mobile devices.
     * The name can be confusing, as it's more like an autofill.
     * You can learn more about it here:
     * https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill
     */
    autoComplete: _propTypes.default.string,
  
    /**
     * If `true`, the input will be focused during the first mount.
     */
    autoFocus: _propTypes.default.bool,
  
    /**
     * Override or extend the styles applied to the component.
     * See [CSS API](#css-api) below for more details.
     */
    classes: _propTypes.default.object.isRequired,
  
    /**
     * The CSS class name of the wrapper element.
     */
    className: _propTypes.default.string,
  
    /**
     * The default input value, useful when not controlling the component.
     */
    defaultValue: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
  
    /**
     * If `true`, the input will be disabled.
     */
    disabled: _propTypes.default.bool,
  
    /**
     * If `true`, the input will not have an underline.
     */
    disableUnderline: _propTypes.default.bool,
  
    /**
     * End `InputAdornment` for this component.
     */
    endAdornment: _propTypes.default.node,
  
    /**
     * If `true`, the input will indicate an error. This is normally obtained via context from
     * FormControl.
     */
    error: _propTypes.default.bool,
  
    /**
     * If `true`, the input will take up the full width of its container.
     */
    fullWidth: _propTypes.default.bool,
  
    /**
     * The id of the `input` element.
     */
    id: _propTypes.default.string,
  
    /**
     * The component used for the native input.
     * Either a string to use a DOM element or a component.
     */
    inputComponent: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.func]),
  
    /**
     * Properties applied to the `input` element.
     */
    inputProps: _propTypes.default.object,
  
    /**
     * Use that property to pass a ref callback to the native input component.
     */
    inputRef: _propTypes.default.func,
  
    /**
     * If `dense`, will adjust vertical spacing. This is normally obtained via context from
     * FormControl.
     */
    margin: _propTypes.default.oneOf(['dense', 'none']),
  
    /**
     * If `true`, a textarea element will be rendered.
     */
    multiline: _propTypes.default.bool,
  
    /**
     * Name attribute of the `input` element.
     */
    name: _propTypes.default.string,
  
    /**
     * @ignore
     */
    onBlur: _propTypes.default.func,
  
    /**
     * Callback fired when the value is changed.
     *
     * @param {object} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value`.
     */
    onChange: _propTypes.default.func,
  
    /**
     * @ignore
     */
    onEmpty: _propTypes.default.func,
  
    /**
     * @ignore
     */
    onFilled: _propTypes.default.func,
  
    /**
     * @ignore
     */
    onFocus: _propTypes.default.func,
  
    /**
     * @ignore
     */
    onKeyDown: _propTypes.default.func,
  
    /**
     * @ignore
     */
    onKeyUp: _propTypes.default.func,
  
    /**
     * The short hint displayed in the input before the user enters a value.
     */
    placeholder: _propTypes.default.string,
  
    /**
     * @ignore
     */
    readOnly: _propTypes.default.bool,
  
    /**
     * Number of rows to display when multiline option is set to true.
     */
    rows: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
  
    /**
     * Maximum number of rows to display when multiline option is set to true.
     */
    rowsMax: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
  
    /**
     * Start `InputAdornment` for this component.
     */
    startAdornment: _propTypes.default.node,
  
    /**
     * Type of the input element. It should be a valid HTML5 input type.
     */
    type: _propTypes.default.string,
  
    /**
     * The input value, required for a controlled component.
     */
    value: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number, _propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]))])
  } : {};
  Input.muiName = 'Input';
  Input.defaultProps = {
    disableUnderline: false,
    fullWidth: false,
    multiline: false,
    type: 'text'
  };
  Input.contextTypes = {
    muiFormControl: _propTypes.default.object
  };
  Input.childContextTypes = {
    muiFormControl: _propTypes.default.object
  };
  
  var _default = (0, _withStyles.default)(styles, {
    name: 'MuiInput'
  })(Input);
  
  exports.default = _default;