antd3-esm 1.0.1

package/dist/index13.js

@@ -0,0 +1,422 @@
+import * as React from 'react';
+import { c as classNames, C as ConfigConsumer, p as propTypesExports } from './config-provider.js';
+import { C as Checkbox } from './Checkbox.js';
+import { s as shallowEqual, p as polyfill } from './menu.js';
+
+function _typeof$2(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$2(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$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$2(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$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); return Constructor; }
+
+function _inherits$2(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$2(subClass, superClass); }
+
+function _setPrototypeOf$2(o, p) { _setPrototypeOf$2 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$2(o, p); }
+
+function _createSuper$2(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2(); return function _createSuperInternal() { var Super = _getPrototypeOf$2(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$2(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$2(this, result); }; }
+
+function _possibleConstructorReturn$2(self, call) { if (call && (_typeof$2(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$2(self); }
+
+function _assertThisInitialized$2(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct$2() { 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$2(o) { _getPrototypeOf$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$2(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 Radio = /*#__PURE__*/function (_React$Component) {
+  _inherits$2(Radio, _React$Component);
+
+  var _super = _createSuper$2(Radio);
+
+  function Radio() {
+    var _this;
+
+    _classCallCheck$2(this, Radio);
+
+    _this = _super.apply(this, arguments);
+
+    _this.saveCheckbox = function (node) {
+      _this.rcCheckbox = node;
+    };
+
+    _this.onChange = function (e) {
+      if (_this.props.onChange) {
+        _this.props.onChange(e);
+      }
+
+      if (_this.context.radioGroup && _this.context.radioGroup.onChange) {
+        _this.context.radioGroup.onChange(e);
+      }
+    };
+
+    _this.renderRadio = function (_ref) {
+      var _classNames;
+
+      var getPrefixCls = _ref.getPrefixCls;
+
+      var _assertThisInitialize = _assertThisInitialized$2(_this),
+          props = _assertThisInitialize.props,
+          context = _assertThisInitialize.context;
+
+      var customizePrefixCls = props.prefixCls,
+          className = props.className,
+          children = props.children,
+          style = props.style,
+          restProps = __rest$1(props, ["prefixCls", "className", "children", "style"]);
+
+      var radioGroup = context.radioGroup;
+      var prefixCls = getPrefixCls('radio', customizePrefixCls);
+
+      var radioProps = _extends$1({}, restProps);
+
+      if (radioGroup) {
+        radioProps.name = radioGroup.name;
+        radioProps.onChange = _this.onChange;
+        radioProps.checked = props.value === radioGroup.value;
+        radioProps.disabled = props.disabled || radioGroup.disabled;
+      }
+
+      var wrapperClassString = classNames(className, (_classNames = {}, _defineProperty$1(_classNames, "".concat(prefixCls, "-wrapper"), true), _defineProperty$1(_classNames, "".concat(prefixCls, "-wrapper-checked"), radioProps.checked), _defineProperty$1(_classNames, "".concat(prefixCls, "-wrapper-disabled"), radioProps.disabled), _classNames));
+      return (
+        /*#__PURE__*/
+        // eslint-disable-next-line jsx-a11y/label-has-associated-control
+        React.createElement("label", {
+          className: wrapperClassString,
+          style: style,
+          onMouseEnter: props.onMouseEnter,
+          onMouseLeave: props.onMouseLeave
+        }, /*#__PURE__*/React.createElement(Checkbox, _extends$1({}, radioProps, {
+          prefixCls: prefixCls,
+          ref: _this.saveCheckbox
+        })), children !== undefined ? /*#__PURE__*/React.createElement("span", null, children) : null)
+      );
+    };
+
+    return _this;
+  }
+
+  _createClass$2(Radio, [{
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(nextProps, nextState, nextContext) {
+      return !shallowEqual(this.props, nextProps) || !shallowEqual(this.state, nextState) || !shallowEqual(this.context.radioGroup, nextContext.radioGroup);
+    }
+  }, {
+    key: "focus",
+    value: function focus() {
+      this.rcCheckbox.focus();
+    }
+  }, {
+    key: "blur",
+    value: function blur() {
+      this.rcCheckbox.blur();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderRadio);
+    }
+  }]);
+
+  return Radio;
+}(React.Component);
+Radio.defaultProps = {
+  type: 'radio'
+};
+Radio.contextTypes = {
+  radioGroup: propTypesExports.any
+};
+
+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(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); if (staticProps) _defineProperties$1(Constructor, staticProps); 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); }
+
+function getCheckedValue(children) {
+  var value = null;
+  var matched = false;
+  React.Children.forEach(children, function (radio) {
+    if (radio && radio.props && radio.props.checked) {
+      value = radio.props.value;
+      matched = true;
+    }
+  });
+  return matched ? {
+    value: value
+  } : undefined;
+}
+
+var RadioGroup = /*#__PURE__*/function (_React$Component) {
+  _inherits$1(RadioGroup, _React$Component);
+
+  var _super = _createSuper$1(RadioGroup);
+
+  function RadioGroup(props) {
+    var _this;
+
+    _classCallCheck$1(this, RadioGroup);
+
+    _this = _super.call(this, props);
+
+    _this.onRadioChange = function (ev) {
+      var lastValue = _this.state.value;
+      var value = ev.target.value;
+
+      if (!('value' in _this.props)) {
+        _this.setState({
+          value: value
+        });
+      }
+
+      var onChange = _this.props.onChange;
+
+      if (onChange && value !== lastValue) {
+        onChange(ev);
+      }
+    };
+
+    _this.renderGroup = function (_ref) {
+      var getPrefixCls = _ref.getPrefixCls;
+
+      var _assertThisInitialize = _assertThisInitialized$1(_this),
+          props = _assertThisInitialize.props;
+
+      var customizePrefixCls = props.prefixCls,
+          _props$className = props.className,
+          className = _props$className === void 0 ? '' : _props$className,
+          options = props.options,
+          buttonStyle = props.buttonStyle;
+      var prefixCls = getPrefixCls('radio', customizePrefixCls);
+      var groupPrefixCls = "".concat(prefixCls, "-group");
+      var classString = classNames(groupPrefixCls, "".concat(groupPrefixCls, "-").concat(buttonStyle), _defineProperty({}, "".concat(groupPrefixCls, "-").concat(props.size), props.size), className);
+      var children = props.children; // 如果存在 options, 优先使用
+
+      if (options && options.length > 0) {
+        children = options.map(function (option) {
+          if (typeof option === 'string') {
+            // 此处类型自动推导为 string
+            return /*#__PURE__*/React.createElement(Radio, {
+              key: option,
+              prefixCls: prefixCls,
+              disabled: _this.props.disabled,
+              value: option,
+              checked: _this.state.value === option
+            }, option);
+          } // 此处类型自动推导为 { label: string value: string }
+
+
+          return /*#__PURE__*/React.createElement(Radio, {
+            key: "radio-group-value-options-".concat(option.value),
+            prefixCls: prefixCls,
+            disabled: option.disabled || _this.props.disabled,
+            value: option.value,
+            checked: _this.state.value === option.value
+          }, option.label);
+        });
+      }
+
+      return /*#__PURE__*/React.createElement("div", {
+        className: classString,
+        style: props.style,
+        onMouseEnter: props.onMouseEnter,
+        onMouseLeave: props.onMouseLeave,
+        id: props.id
+      }, children);
+    };
+
+    var value;
+
+    if ('value' in props) {
+      value = props.value;
+    } else if ('defaultValue' in props) {
+      value = props.defaultValue;
+    } else {
+      var checkedValue = getCheckedValue(props.children);
+      value = checkedValue && checkedValue.value;
+    }
+
+    _this.state = {
+      value: value
+    };
+    return _this;
+  }
+
+  _createClass$1(RadioGroup, [{
+    key: "getChildContext",
+    value: function getChildContext() {
+      return {
+        radioGroup: {
+          onChange: this.onRadioChange,
+          value: this.state.value,
+          disabled: this.props.disabled,
+          name: this.props.name
+        }
+      };
+    }
+  }, {
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(nextProps, nextState) {
+      return !shallowEqual(this.props, nextProps) || !shallowEqual(this.state, nextState);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderGroup);
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps) {
+      if ('value' in nextProps) {
+        return {
+          value: nextProps.value
+        };
+      }
+
+      var checkedValue = getCheckedValue(nextProps.children);
+
+      if (checkedValue) {
+        return {
+          value: checkedValue.value
+        };
+      }
+
+      return null;
+    }
+  }]);
+
+  return RadioGroup;
+}(React.Component);
+
+RadioGroup.defaultProps = {
+  buttonStyle: 'outline'
+};
+RadioGroup.childContextTypes = {
+  radioGroup: propTypesExports.any
+};
+polyfill(RadioGroup);
+
+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); 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 RadioButton = /*#__PURE__*/function (_React$Component) {
+  _inherits(RadioButton, _React$Component);
+
+  var _super = _createSuper(RadioButton);
+
+  function RadioButton() {
+    var _this;
+
+    _classCallCheck(this, RadioButton);
+
+    _this = _super.apply(this, arguments);
+
+    _this.renderRadioButton = function (_ref) {
+      var getPrefixCls = _ref.getPrefixCls;
+
+      var _a = _this.props,
+          customizePrefixCls = _a.prefixCls,
+          radioProps = __rest(_a, ["prefixCls"]);
+
+      var prefixCls = getPrefixCls('radio-button', customizePrefixCls);
+
+      if (_this.context.radioGroup) {
+        radioProps.checked = _this.props.value === _this.context.radioGroup.value;
+        radioProps.disabled = _this.props.disabled || _this.context.radioGroup.disabled;
+      }
+
+      return /*#__PURE__*/React.createElement(Radio, _extends({
+        prefixCls: prefixCls
+      }, radioProps));
+    };
+
+    return _this;
+  }
+
+  _createClass(RadioButton, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderRadioButton);
+    }
+  }]);
+
+  return RadioButton;
+}(React.Component);
+RadioButton.contextTypes = {
+  radioGroup: propTypesExports.any
+};
+
+Radio.Button = RadioButton;
+Radio.Group = RadioGroup;
+
+export { RadioButton as R, RadioGroup as a, Radio as b };