antd3-esm 1.0.1

package/dist/index10.js

@@ -0,0 +1,478 @@
+import { I as Input, o as omit } from './input.js';
+import * as React from 'react';
+import { C as ConfigConsumer, c as classNames } from './config-provider.js';
+import { I as Icon } from './icon.js';
+import { B as Button } from './index7.js';
+import { T as TextArea } from './TextArea.js';
+
+function _defineProperty$2(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 Group = function Group(props) {
+  return /*#__PURE__*/React.createElement(ConfigConsumer, null, function (_ref) {
+    var _classNames;
+
+    var getPrefixCls = _ref.getPrefixCls;
+    var customizePrefixCls = props.prefixCls,
+        _props$className = props.className,
+        className = _props$className === void 0 ? '' : _props$className;
+    var prefixCls = getPrefixCls('input-group', customizePrefixCls);
+    var cls = classNames(prefixCls, (_classNames = {}, _defineProperty$2(_classNames, "".concat(prefixCls, "-lg"), props.size === 'large'), _defineProperty$2(_classNames, "".concat(prefixCls, "-sm"), props.size === 'small'), _defineProperty$2(_classNames, "".concat(prefixCls, "-compact"), props.compact), _classNames), className);
+    return /*#__PURE__*/React.createElement("span", {
+      className: cls,
+      style: props.style,
+      onMouseEnter: props.onMouseEnter,
+      onMouseLeave: props.onMouseLeave,
+      onFocus: props.onFocus,
+      onBlur: props.onBlur
+    }, props.children);
+  });
+};
+
+var isMobile = {exports: {}};
+
+var hasRequiredIsMobile;
+
+function requireIsMobile () {
+	if (hasRequiredIsMobile) return isMobile.exports;
+	hasRequiredIsMobile = 1;
+
+	isMobile.exports = isMobile$1;
+	isMobile.exports.isMobile = isMobile$1;
+	isMobile.exports.default = isMobile$1;
+
+	var mobileRE = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series[46]0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i;
+
+	var tabletRE = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series[46]0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino|android|ipad|playbook|silk/i;
+
+	function isMobile$1 (opts) {
+	  if (!opts) opts = {};
+	  var ua = opts.ua;
+	  if (!ua && typeof navigator !== 'undefined') ua = navigator.userAgent;
+	  if (ua && ua.headers && typeof ua.headers['user-agent'] === 'string') {
+	    ua = ua.headers['user-agent'];
+	  }
+	  if (typeof ua !== 'string') return false
+
+	  var result = opts.tablet ? tabletRE.test(ua) : mobileRE.test(ua);
+
+	  if (
+	    !result &&
+	    opts.tablet &&
+	    opts.featureDetect &&
+	    navigator &&
+	    navigator.maxTouchPoints > 1 &&
+	    ua.indexOf('Macintosh') !== -1 &&
+	    ua.indexOf('Safari') !== -1
+	  ) {
+	    result = true;
+	  }
+
+	  return result
+	}
+	return isMobile.exports;
+}
+
+var isMobileExports = requireIsMobile();
+
+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 _extends$1() { _extends$1 = 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$1.apply(this, arguments); }
+
+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 __rest$1 = undefined && undefined.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+var Search = /*#__PURE__*/function (_React$Component) {
+  _inherits$1(Search, _React$Component);
+
+  var _super = _createSuper$1(Search);
+
+  function Search() {
+    var _this;
+
+    _classCallCheck$1(this, Search);
+
+    _this = _super.apply(this, arguments);
+
+    _this.saveInput = function (node) {
+      _this.input = node;
+    };
+
+    _this.onChange = function (e) {
+      var _this$props = _this.props,
+          onChange = _this$props.onChange,
+          onSearch = _this$props.onSearch;
+
+      if (e && e.target && e.type === 'click' && onSearch) {
+        onSearch(e.target.value, e);
+      }
+
+      if (onChange) {
+        onChange(e);
+      }
+    };
+
+    _this.onSearch = function (e) {
+      var _this$props2 = _this.props,
+          onSearch = _this$props2.onSearch,
+          loading = _this$props2.loading,
+          disabled = _this$props2.disabled;
+
+      if (loading || disabled) {
+        return;
+      }
+
+      if (onSearch) {
+        onSearch(_this.input.input.value, e);
+      }
+
+      if (!isMobileExports.isMobile({
+        tablet: true
+      })) {
+        _this.input.focus();
+      }
+    };
+
+    _this.renderLoading = function (prefixCls) {
+      var _this$props3 = _this.props,
+          enterButton = _this$props3.enterButton,
+          size = _this$props3.size;
+
+      if (enterButton) {
+        return /*#__PURE__*/React.createElement(Button, {
+          className: "".concat(prefixCls, "-button"),
+          type: "primary",
+          size: size,
+          key: "enterButton"
+        }, /*#__PURE__*/React.createElement(Icon, {
+          type: "loading"
+        }));
+      }
+
+      return /*#__PURE__*/React.createElement(Icon, {
+        className: "".concat(prefixCls, "-icon"),
+        type: "loading",
+        key: "loadingIcon"
+      });
+    };
+
+    _this.renderSuffix = function (prefixCls) {
+      var _this$props4 = _this.props,
+          suffix = _this$props4.suffix,
+          enterButton = _this$props4.enterButton,
+          loading = _this$props4.loading;
+
+      if (loading && !enterButton) {
+        return [suffix, _this.renderLoading(prefixCls)];
+      }
+
+      if (enterButton) return suffix;
+      var icon = /*#__PURE__*/React.createElement(Icon, {
+        className: "".concat(prefixCls, "-icon"),
+        type: "search",
+        key: "searchIcon",
+        onClick: _this.onSearch
+      });
+
+      if (suffix) {
+        return [/*#__PURE__*/React.isValidElement(suffix) ? /*#__PURE__*/React.cloneElement(suffix, {
+          key: 'suffix'
+        }) : null, icon];
+      }
+
+      return icon;
+    };
+
+    _this.renderAddonAfter = function (prefixCls) {
+      var _this$props5 = _this.props,
+          enterButton = _this$props5.enterButton,
+          size = _this$props5.size,
+          disabled = _this$props5.disabled,
+          addonAfter = _this$props5.addonAfter,
+          loading = _this$props5.loading;
+      var btnClassName = "".concat(prefixCls, "-button");
+
+      if (loading && enterButton) {
+        return [_this.renderLoading(prefixCls), addonAfter];
+      }
+
+      if (!enterButton) return addonAfter;
+      var button;
+      var enterButtonAsElement = enterButton;
+      var isAntdButton = enterButtonAsElement.type && enterButtonAsElement.type.__ANT_BUTTON === true;
+
+      if (isAntdButton || enterButtonAsElement.type === 'button') {
+        button = /*#__PURE__*/React.cloneElement(enterButtonAsElement, _extends$1({
+          onClick: _this.onSearch,
+          key: 'enterButton'
+        }, isAntdButton ? {
+          className: btnClassName,
+          size: size
+        } : {}));
+      } else {
+        button = /*#__PURE__*/React.createElement(Button, {
+          className: btnClassName,
+          type: "primary",
+          size: size,
+          disabled: disabled,
+          key: "enterButton",
+          onClick: _this.onSearch
+        }, enterButton === true ? /*#__PURE__*/React.createElement(Icon, {
+          type: "search"
+        }) : enterButton);
+      }
+
+      if (addonAfter) {
+        return [button, /*#__PURE__*/React.isValidElement(addonAfter) ? /*#__PURE__*/React.cloneElement(addonAfter, {
+          key: 'addonAfter'
+        }) : null];
+      }
+
+      return button;
+    };
+
+    _this.renderSearch = function (_ref) {
+      var getPrefixCls = _ref.getPrefixCls;
+
+      var _a = _this.props,
+          customizePrefixCls = _a.prefixCls,
+          customizeInputPrefixCls = _a.inputPrefixCls,
+          size = _a.size,
+          enterButton = _a.enterButton,
+          className = _a.className,
+          restProps = __rest$1(_a, ["prefixCls", "inputPrefixCls", "size", "enterButton", "className"]);
+
+      delete restProps.onSearch;
+      delete restProps.loading;
+      var prefixCls = getPrefixCls('input-search', customizePrefixCls);
+      var inputPrefixCls = getPrefixCls('input', customizeInputPrefixCls);
+      var inputClassName;
+
+      if (enterButton) {
+        var _classNames;
+
+        inputClassName = classNames(prefixCls, className, (_classNames = {}, _defineProperty$1(_classNames, "".concat(prefixCls, "-enter-button"), !!enterButton), _defineProperty$1(_classNames, "".concat(prefixCls, "-").concat(size), !!size), _classNames));
+      } else {
+        inputClassName = classNames(prefixCls, className);
+      }
+
+      return /*#__PURE__*/React.createElement(Input, _extends$1({
+        onPressEnter: _this.onSearch
+      }, restProps, {
+        size: size,
+        prefixCls: inputPrefixCls,
+        addonAfter: _this.renderAddonAfter(prefixCls),
+        suffix: _this.renderSuffix(prefixCls),
+        onChange: _this.onChange,
+        ref: _this.saveInput,
+        className: inputClassName
+      }));
+    };
+
+    return _this;
+  }
+
+  _createClass$1(Search, [{
+    key: "focus",
+    value: function focus() {
+      this.input.focus();
+    }
+  }, {
+    key: "blur",
+    value: function blur() {
+      this.input.blur();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderSearch);
+    }
+  }]);
+
+  return Search;
+}(React.Component);
+Search.defaultProps = {
+  enterButton: false
+};
+
+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 _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; }
+
+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); 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); }
+
+var __rest = undefined && undefined.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+var ActionMap = {
+  click: 'onClick',
+  hover: 'onMouseOver'
+};
+
+var Password = /*#__PURE__*/function (_React$Component) {
+  _inherits(Password, _React$Component);
+
+  var _super = _createSuper(Password);
+
+  function Password() {
+    var _this;
+
+    _classCallCheck(this, Password);
+
+    _this = _super.apply(this, arguments);
+    _this.state = {
+      visible: false
+    };
+
+    _this.onVisibleChange = function () {
+      var disabled = _this.props.disabled;
+
+      if (disabled) {
+        return;
+      }
+
+      _this.setState(function (_ref) {
+        var visible = _ref.visible;
+        return {
+          visible: !visible
+        };
+      });
+    };
+
+    _this.saveInput = function (instance) {
+      if (instance && instance.input) {
+        _this.input = instance.input;
+      }
+    };
+
+    return _this;
+  }
+
+  _createClass(Password, [{
+    key: "getIcon",
+    value: function getIcon() {
+      var _iconProps;
+
+      var _this$props = this.props,
+          prefixCls = _this$props.prefixCls,
+          action = _this$props.action;
+      var iconTrigger = ActionMap[action] || '';
+      var iconProps = (_iconProps = {}, _defineProperty(_iconProps, iconTrigger, this.onVisibleChange), _defineProperty(_iconProps, "className", "".concat(prefixCls, "-icon")), _defineProperty(_iconProps, "type", this.state.visible ? 'eye' : 'eye-invisible'), _defineProperty(_iconProps, "key", 'passwordIcon'), _defineProperty(_iconProps, "onMouseDown", function onMouseDown(e) {
+        // Prevent focused state lost
+        // https://github.com/ant-design/ant-design/issues/15173
+        e.preventDefault();
+      }), _iconProps);
+      return /*#__PURE__*/React.createElement(Icon, iconProps);
+    }
+  }, {
+    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: "render",
+    value: function render() {
+      var _a = this.props,
+          className = _a.className,
+          prefixCls = _a.prefixCls,
+          inputPrefixCls = _a.inputPrefixCls,
+          size = _a.size,
+          visibilityToggle = _a.visibilityToggle,
+          restProps = __rest(_a, ["className", "prefixCls", "inputPrefixCls", "size", "visibilityToggle"]);
+
+      var suffixIcon = visibilityToggle && this.getIcon();
+      var inputClassName = classNames(prefixCls, className, _defineProperty({}, "".concat(prefixCls, "-").concat(size), !!size));
+      return /*#__PURE__*/React.createElement(Input, _extends({}, omit(restProps, ['suffix']), {
+        type: this.state.visible ? 'text' : 'password',
+        size: size,
+        className: inputClassName,
+        prefixCls: inputPrefixCls,
+        suffix: suffixIcon,
+        ref: this.saveInput
+      }));
+    }
+  }]);
+
+  return Password;
+}(React.Component);
+Password.defaultProps = {
+  inputPrefixCls: 'ant-input',
+  prefixCls: 'ant-input-password',
+  action: 'click',
+  visibilityToggle: true
+};
+
+Input.Group = Group;
+Input.Search = Search;
+Input.TextArea = TextArea;
+Input.Password = Password;