antd3-esm 1.0.1

package/dist/input.js

@@ -0,0 +1,475 @@
+import * as React from 'react';
+import { c as classNames, C as ConfigConsumer, p as propTypesExports } from './config-provider.js';
+import { p as polyfill } from './menu.js';
+import { e as _extends$1, I as Icon } from './icon.js';
+
+function omit(obj, fields) {
+  var shallowCopy = _extends$1({}, obj);
+  for (var i = 0; i < fields.length; i++) {
+    var key = fields[i];
+    delete shallowCopy[key];
+  }
+  return shallowCopy;
+}
+
+// https://stackoverflow.com/questions/46176165/ways-to-get-string-literal-type-of-array-values-without-enum-overhead
+var tuple = function tuple() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return args;
+};
+var tupleNum = function tupleNum() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+
+  return args;
+};
+
+function _typeof$1(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); }
+
+function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$1(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, descriptor.key, descriptor); } }
+
+function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); return Constructor; }
+
+function _inherits$1(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1(subClass, superClass); }
+
+function _setPrototypeOf$1(o, p) { _setPrototypeOf$1 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1(o, p); }
+
+function _createSuper$1(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1(); return function _createSuperInternal() { var Super = _getPrototypeOf$1(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1(this, result); }; }
+
+function _possibleConstructorReturn$1(self, call) { if (call && (_typeof$1(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1(self); }
+
+function _assertThisInitialized$1(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct$1() { 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; } }
+
+function _getPrototypeOf$1(o) { _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1(o); }
+var ClearableInputType = tuple('text', 'input');
+function hasPrefixSuffix(props) {
+  return !!(props.prefix || props.suffix || props.allowClear);
+}
+
+var ClearableLabeledInput = /*#__PURE__*/function (_React$Component) {
+  _inherits$1(ClearableLabeledInput, _React$Component);
+
+  var _super = _createSuper$1(ClearableLabeledInput);
+
+  function ClearableLabeledInput() {
+    _classCallCheck$1(this, ClearableLabeledInput);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass$1(ClearableLabeledInput, [{
+    key: "renderClearIcon",
+    value: function renderClearIcon(prefixCls) {
+      var _this$props = this.props,
+          allowClear = _this$props.allowClear,
+          value = _this$props.value,
+          disabled = _this$props.disabled,
+          readOnly = _this$props.readOnly,
+          inputType = _this$props.inputType,
+          handleReset = _this$props.handleReset;
+
+      if (!allowClear || disabled || readOnly || value === undefined || value === null || value === '') {
+        return null;
+      }
+
+      var className = inputType === ClearableInputType[0] ? "".concat(prefixCls, "-textarea-clear-icon") : "".concat(prefixCls, "-clear-icon");
+      return /*#__PURE__*/React.createElement(Icon, {
+        type: "close-circle",
+        theme: "filled",
+        onClick: handleReset,
+        className: className,
+        role: "button"
+      });
+    }
+  }, {
+    key: "renderSuffix",
+    value: function renderSuffix(prefixCls) {
+      var _this$props2 = this.props,
+          suffix = _this$props2.suffix,
+          allowClear = _this$props2.allowClear;
+
+      if (suffix || allowClear) {
+        return /*#__PURE__*/React.createElement("span", {
+          className: "".concat(prefixCls, "-suffix")
+        }, this.renderClearIcon(prefixCls), suffix);
+      }
+
+      return null;
+    }
+  }, {
+    key: "renderLabeledIcon",
+    value: function renderLabeledIcon(prefixCls, element) {
+      var _classNames;
+
+      var props = this.props;
+      var suffix = this.renderSuffix(prefixCls);
+
+      if (!hasPrefixSuffix(props)) {
+        return /*#__PURE__*/React.cloneElement(element, {
+          value: props.value
+        });
+      }
+
+      var prefix = props.prefix ? /*#__PURE__*/React.createElement("span", {
+        className: "".concat(prefixCls, "-prefix")
+      }, props.prefix) : null;
+      var affixWrapperCls = classNames(props.className, "".concat(prefixCls, "-affix-wrapper"), (_classNames = {}, _defineProperty$1(_classNames, "".concat(prefixCls, "-affix-wrapper-sm"), props.size === 'small'), _defineProperty$1(_classNames, "".concat(prefixCls, "-affix-wrapper-lg"), props.size === 'large'), _defineProperty$1(_classNames, "".concat(prefixCls, "-affix-wrapper-input-with-clear-btn"), props.suffix && props.allowClear && this.props.value), _classNames));
+      return /*#__PURE__*/React.createElement("span", {
+        className: affixWrapperCls,
+        style: props.style
+      }, prefix, /*#__PURE__*/React.cloneElement(element, {
+        style: null,
+        value: props.value,
+        className: getInputClassName(prefixCls, props.size, props.disabled)
+      }), suffix);
+    }
+  }, {
+    key: "renderInputWithLabel",
+    value: function renderInputWithLabel(prefixCls, labeledElement) {
+      var _classNames3;
+
+      var _this$props3 = this.props,
+          addonBefore = _this$props3.addonBefore,
+          addonAfter = _this$props3.addonAfter,
+          style = _this$props3.style,
+          size = _this$props3.size,
+          className = _this$props3.className; // Not wrap when there is not addons
+
+      if (!addonBefore && !addonAfter) {
+        return labeledElement;
+      }
+
+      var wrapperClassName = "".concat(prefixCls, "-group");
+      var addonClassName = "".concat(wrapperClassName, "-addon");
+      var addonBeforeNode = addonBefore ? /*#__PURE__*/React.createElement("span", {
+        className: addonClassName
+      }, addonBefore) : null;
+      var addonAfterNode = addonAfter ? /*#__PURE__*/React.createElement("span", {
+        className: addonClassName
+      }, addonAfter) : null;
+      var mergedWrapperClassName = classNames("".concat(prefixCls, "-wrapper"), _defineProperty$1({}, wrapperClassName, addonBefore || addonAfter));
+      var mergedGroupClassName = classNames(className, "".concat(prefixCls, "-group-wrapper"), (_classNames3 = {}, _defineProperty$1(_classNames3, "".concat(prefixCls, "-group-wrapper-sm"), size === 'small'), _defineProperty$1(_classNames3, "".concat(prefixCls, "-group-wrapper-lg"), size === 'large'), _classNames3)); // Need another wrapper for changing display:table to display:inline-block
+      // and put style prop in wrapper
+
+      return /*#__PURE__*/React.createElement("span", {
+        className: mergedGroupClassName,
+        style: style
+      }, /*#__PURE__*/React.createElement("span", {
+        className: mergedWrapperClassName
+      }, addonBeforeNode, /*#__PURE__*/React.cloneElement(labeledElement, {
+        style: null
+      }), addonAfterNode));
+    }
+  }, {
+    key: "renderTextAreaWithClearIcon",
+    value: function renderTextAreaWithClearIcon(prefixCls, element) {
+      var _this$props4 = this.props,
+          value = _this$props4.value,
+          allowClear = _this$props4.allowClear,
+          className = _this$props4.className,
+          style = _this$props4.style;
+
+      if (!allowClear) {
+        return /*#__PURE__*/React.cloneElement(element, {
+          value: value
+        });
+      }
+
+      var affixWrapperCls = classNames(className, "".concat(prefixCls, "-affix-wrapper"), "".concat(prefixCls, "-affix-wrapper-textarea-with-clear-btn"));
+      return /*#__PURE__*/React.createElement("span", {
+        className: affixWrapperCls,
+        style: style
+      }, /*#__PURE__*/React.cloneElement(element, {
+        style: null,
+        value: value
+      }), this.renderClearIcon(prefixCls));
+    }
+  }, {
+    key: "renderClearableLabeledInput",
+    value: function renderClearableLabeledInput() {
+      var _this$props5 = this.props,
+          prefixCls = _this$props5.prefixCls,
+          inputType = _this$props5.inputType,
+          element = _this$props5.element;
+
+      if (inputType === ClearableInputType[0]) {
+        return this.renderTextAreaWithClearIcon(prefixCls, element);
+      }
+
+      return this.renderInputWithLabel(prefixCls, this.renderLabeledIcon(prefixCls, element));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return this.renderClearableLabeledInput();
+    }
+  }]);
+
+  return ClearableLabeledInput;
+}(React.Component);
+
+polyfill(ClearableLabeledInput);
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _extends() { _extends = Object.assign || 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 _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, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+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 _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+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; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var InputSizes = tuple('small', 'default', 'large');
+function fixControlledValue(value) {
+  if (typeof value === 'undefined' || value === null) {
+    return '';
+  }
+
+  return value;
+}
+function resolveOnChange(target, e, onChange) {
+  if (onChange) {
+    var event = e;
+
+    if (e.type === 'click') {
+      // click clear icon
+      event = Object.create(e);
+      event.target = target;
+      event.currentTarget = target;
+      var originalInputValue = target.value; // change target ref value cause e.target.value should be '' when clear input
+
+      target.value = '';
+      onChange(event); // reset target ref value
+
+      target.value = originalInputValue;
+      return;
+    }
+
+    onChange(event);
+  }
+}
+function getInputClassName(prefixCls, size, disabled) {
+  var _classNames;
+
+  return classNames(prefixCls, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-sm"), size === 'small'), _defineProperty(_classNames, "".concat(prefixCls, "-lg"), size === 'large'), _defineProperty(_classNames, "".concat(prefixCls, "-disabled"), disabled), _classNames));
+}
+
+var Input = /*#__PURE__*/function (_React$Component) {
+  _inherits(Input, _React$Component);
+
+  var _super = _createSuper(Input);
+
+  function Input(props) {
+    var _this;
+
+    _classCallCheck(this, Input);
+
+    _this = _super.call(this, props);
+
+    _this.saveClearableInput = function (input) {
+      _this.clearableInput = input;
+    };
+
+    _this.saveInput = function (input) {
+      _this.input = input;
+    };
+
+    _this.handleReset = function (e) {
+      _this.setValue('', function () {
+        _this.focus();
+      });
+
+      resolveOnChange(_this.input, e, _this.props.onChange);
+    };
+
+    _this.renderInput = function (prefixCls) {
+      var _this$props = _this.props,
+          className = _this$props.className,
+          addonBefore = _this$props.addonBefore,
+          addonAfter = _this$props.addonAfter,
+          size = _this$props.size,
+          disabled = _this$props.disabled; // Fix https://fb.me/react-unknown-prop
+
+      var otherProps = omit(_this.props, ['prefixCls', 'onPressEnter', 'addonBefore', 'addonAfter', 'prefix', 'suffix', 'allowClear', // Input elements must be either controlled or uncontrolled,
+      // specify either the value prop, or the defaultValue prop, but not both.
+      'defaultValue', 'size', 'inputType']);
+      return /*#__PURE__*/React.createElement("input", _extends({}, otherProps, {
+        onChange: _this.handleChange,
+        onKeyDown: _this.handleKeyDown,
+        className: classNames(getInputClassName(prefixCls, size, disabled), _defineProperty({}, className, className && !addonBefore && !addonAfter)),
+        ref: _this.saveInput
+      }));
+    };
+
+    _this.clearPasswordValueAttribute = function () {
+      // https://github.com/ant-design/ant-design/issues/20541
+      _this.removePasswordTimeout = setTimeout(function () {
+        if (_this.input && _this.input.getAttribute('type') === 'password' && _this.input.hasAttribute('value')) {
+          _this.input.removeAttribute('value');
+        }
+      });
+    };
+
+    _this.handleChange = function (e) {
+      _this.setValue(e.target.value, _this.clearPasswordValueAttribute);
+
+      resolveOnChange(_this.input, e, _this.props.onChange);
+    };
+
+    _this.handleKeyDown = function (e) {
+      var _this$props2 = _this.props,
+          onPressEnter = _this$props2.onPressEnter,
+          onKeyDown = _this$props2.onKeyDown;
+
+      if (e.keyCode === 13 && onPressEnter) {
+        onPressEnter(e);
+      }
+
+      if (onKeyDown) {
+        onKeyDown(e);
+      }
+    };
+
+    _this.renderComponent = function (_ref) {
+      var getPrefixCls = _ref.getPrefixCls;
+      var value = _this.state.value;
+      var customizePrefixCls = _this.props.prefixCls;
+      var prefixCls = getPrefixCls('input', customizePrefixCls);
+      return /*#__PURE__*/React.createElement(ClearableLabeledInput, _extends({}, _this.props, {
+        prefixCls: prefixCls,
+        inputType: "input",
+        value: fixControlledValue(value),
+        element: _this.renderInput(prefixCls),
+        handleReset: _this.handleReset,
+        ref: _this.saveClearableInput
+      }));
+    };
+
+    var value = typeof props.value === 'undefined' ? props.defaultValue : props.value;
+    _this.state = {
+      value: value
+    };
+    return _this;
+  }
+
+  _createClass(Input, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.clearPasswordValueAttribute();
+    } // Since polyfill `getSnapshotBeforeUpdate` need work with `componentDidUpdate`.
+    // We keep an empty function here.
+
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {}
+  }, {
+    key: "getSnapshotBeforeUpdate",
+    value: function getSnapshotBeforeUpdate(prevProps) {
+
+      return null;
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.removePasswordTimeout) {
+        clearTimeout(this.removePasswordTimeout);
+      }
+    }
+  }, {
+    key: "focus",
+    value: function focus() {
+      this.input.focus();
+    }
+  }, {
+    key: "blur",
+    value: function blur() {
+      this.input.blur();
+    }
+  }, {
+    key: "select",
+    value: function select() {
+      this.input.select();
+    }
+  }, {
+    key: "setValue",
+    value: function setValue(value, callback) {
+      if (!('value' in this.props)) {
+        this.setState({
+          value: value
+        }, callback);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderComponent);
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps) {
+      if ('value' in nextProps) {
+        return {
+          value: nextProps.value
+        };
+      }
+
+      return null;
+    }
+  }]);
+
+  return Input;
+}(React.Component);
+
+Input.defaultProps = {
+  type: 'text'
+};
+Input.propTypes = {
+  type: propTypesExports.string,
+  id: propTypesExports.string,
+  size: propTypesExports.oneOf(InputSizes),
+  maxLength: propTypesExports.number,
+  disabled: propTypesExports.bool,
+  value: propTypesExports.any,
+  defaultValue: propTypesExports.any,
+  className: propTypesExports.string,
+  addonBefore: propTypesExports.node,
+  addonAfter: propTypesExports.node,
+  prefixCls: propTypesExports.string,
+  onPressEnter: propTypesExports.func,
+  onKeyDown: propTypesExports.func,
+  onKeyUp: propTypesExports.func,
+  onFocus: propTypesExports.func,
+  onBlur: propTypesExports.func,
+  prefix: propTypesExports.node,
+  suffix: propTypesExports.node,
+  allowClear: propTypesExports.bool
+};
+polyfill(Input);
+
+export { ClearableLabeledInput as C, Input as I, tupleNum as a, fixControlledValue as f, omit as o, resolveOnChange as r, tuple as t };