antd3-esm 1.0.1

package/dist/index8.js

@@ -0,0 +1,436 @@
+import * as React from 'react';
+import { c as classNames, C as ConfigConsumer, p as propTypesExports } from './config-provider.js';
+import { s as shallowEqual, p as polyfill } from './menu.js';
+import { C as Checkbox$1 } from './Checkbox.js';
+import { o as omit } from './input.js';
+
+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 _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 Checkbox = /*#__PURE__*/function (_React$Component) {
+  _inherits$1(Checkbox, _React$Component);
+
+  var _super = _createSuper$1(Checkbox);
+
+  function Checkbox() {
+    var _this;
+
+    _classCallCheck$1(this, Checkbox);
+
+    _this = _super.apply(this, arguments);
+
+    _this.saveCheckbox = function (node) {
+      _this.rcCheckbox = node;
+    };
+
+    _this.renderCheckbox = function (_ref) {
+      var _classNames;
+
+      var getPrefixCls = _ref.getPrefixCls;
+
+      var _assertThisInitialize = _assertThisInitialized$1(_this),
+          props = _assertThisInitialize.props,
+          context = _assertThisInitialize.context;
+
+      var customizePrefixCls = props.prefixCls,
+          className = props.className,
+          children = props.children,
+          indeterminate = props.indeterminate,
+          style = props.style,
+          onMouseEnter = props.onMouseEnter,
+          onMouseLeave = props.onMouseLeave,
+          restProps = __rest$1(props, ["prefixCls", "className", "children", "indeterminate", "style", "onMouseEnter", "onMouseLeave"]);
+
+      var checkboxGroup = context.checkboxGroup;
+      var prefixCls = getPrefixCls('checkbox', customizePrefixCls);
+
+      var checkboxProps = _extends$1({}, restProps);
+
+      if (checkboxGroup) {
+        checkboxProps.onChange = function () {
+          if (restProps.onChange) {
+            restProps.onChange.apply(restProps, arguments);
+          }
+
+          checkboxGroup.toggleOption({
+            label: children,
+            value: props.value
+          });
+        };
+
+        checkboxProps.name = checkboxGroup.name;
+        checkboxProps.checked = checkboxGroup.value.indexOf(props.value) !== -1;
+        checkboxProps.disabled = props.disabled || checkboxGroup.disabled;
+      }
+
+      var classString = classNames(className, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-wrapper"), true), _defineProperty(_classNames, "".concat(prefixCls, "-wrapper-checked"), checkboxProps.checked), _defineProperty(_classNames, "".concat(prefixCls, "-wrapper-disabled"), checkboxProps.disabled), _classNames));
+      var checkboxClass = classNames(_defineProperty({}, "".concat(prefixCls, "-indeterminate"), indeterminate));
+      return (
+        /*#__PURE__*/
+        // eslint-disable-next-line jsx-a11y/label-has-associated-control
+        React.createElement("label", {
+          className: classString,
+          style: style,
+          onMouseEnter: onMouseEnter,
+          onMouseLeave: onMouseLeave
+        }, /*#__PURE__*/React.createElement(Checkbox$1, _extends$1({}, checkboxProps, {
+          prefixCls: prefixCls,
+          className: checkboxClass,
+          ref: _this.saveCheckbox
+        })), children !== undefined && /*#__PURE__*/React.createElement("span", null, children))
+      );
+    };
+
+    return _this;
+  }
+
+  _createClass$1(Checkbox, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var value = this.props.value;
+
+      var _ref2 = this.context || {},
+          _ref2$checkboxGroup = _ref2.checkboxGroup,
+          checkboxGroup = _ref2$checkboxGroup === void 0 ? {} : _ref2$checkboxGroup;
+
+      if (checkboxGroup.registerValue) {
+        checkboxGroup.registerValue(value);
+      }
+    }
+  }, {
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(nextProps, nextState, nextContext) {
+      return !shallowEqual(this.props, nextProps) || !shallowEqual(this.state, nextState) || !shallowEqual(this.context.checkboxGroup, nextContext.checkboxGroup);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(_ref3) {
+      var prevValue = _ref3.value;
+      var value = this.props.value;
+
+      var _ref4 = this.context || {},
+          _ref4$checkboxGroup = _ref4.checkboxGroup,
+          checkboxGroup = _ref4$checkboxGroup === void 0 ? {} : _ref4$checkboxGroup;
+
+      if (value !== prevValue && checkboxGroup.registerValue && checkboxGroup.cancelValue) {
+        checkboxGroup.cancelValue(prevValue);
+        checkboxGroup.registerValue(value);
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      var value = this.props.value;
+
+      var _ref5 = this.context || {},
+          _ref5$checkboxGroup = _ref5.checkboxGroup,
+          checkboxGroup = _ref5$checkboxGroup === void 0 ? {} : _ref5$checkboxGroup;
+
+      if (checkboxGroup.cancelValue) {
+        checkboxGroup.cancelValue(value);
+      }
+    }
+  }, {
+    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.renderCheckbox);
+    }
+  }]);
+
+  return Checkbox;
+}(React.Component);
+
+Checkbox.__ANT_CHECKBOX = true;
+Checkbox.defaultProps = {
+  indeterminate: false
+};
+Checkbox.contextTypes = {
+  checkboxGroup: propTypesExports.any
+};
+polyfill(Checkbox);
+
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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); }
+
+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 CheckboxGroup = /*#__PURE__*/function (_React$Component) {
+  _inherits(CheckboxGroup, _React$Component);
+
+  var _super = _createSuper(CheckboxGroup);
+
+  function CheckboxGroup(props) {
+    var _this;
+
+    _classCallCheck(this, CheckboxGroup);
+
+    _this = _super.call(this, props);
+
+    _this.cancelValue = function (value) {
+      _this.setState(function (_ref) {
+        var registeredValues = _ref.registeredValues;
+        return {
+          registeredValues: registeredValues.filter(function (val) {
+            return val !== value;
+          })
+        };
+      });
+    };
+
+    _this.registerValue = function (value) {
+      _this.setState(function (_ref2) {
+        var registeredValues = _ref2.registeredValues;
+        return {
+          registeredValues: [].concat(_toConsumableArray(registeredValues), [value])
+        };
+      });
+    };
+
+    _this.toggleOption = function (option) {
+      var registeredValues = _this.state.registeredValues;
+
+      var optionIndex = _this.state.value.indexOf(option.value);
+
+      var value = _toConsumableArray(_this.state.value);
+
+      if (optionIndex === -1) {
+        value.push(option.value);
+      } else {
+        value.splice(optionIndex, 1);
+      }
+
+      if (!('value' in _this.props)) {
+        _this.setState({
+          value: value
+        });
+      }
+
+      var onChange = _this.props.onChange;
+
+      if (onChange) {
+        var options = _this.getOptions();
+
+        onChange(value.filter(function (val) {
+          return registeredValues.indexOf(val) !== -1;
+        }).sort(function (a, b) {
+          var indexA = options.findIndex(function (opt) {
+            return opt.value === a;
+          });
+          var indexB = options.findIndex(function (opt) {
+            return opt.value === b;
+          });
+          return indexA - indexB;
+        }));
+      }
+    };
+
+    _this.renderGroup = function (_ref3) {
+      var getPrefixCls = _ref3.getPrefixCls;
+
+      var _assertThisInitialize = _assertThisInitialized(_this),
+          props = _assertThisInitialize.props,
+          state = _assertThisInitialize.state;
+
+      var customizePrefixCls = props.prefixCls,
+          className = props.className,
+          style = props.style,
+          options = props.options,
+          restProps = __rest(props, ["prefixCls", "className", "style", "options"]);
+
+      var prefixCls = getPrefixCls('checkbox', customizePrefixCls);
+      var groupPrefixCls = "".concat(prefixCls, "-group");
+      var domProps = omit(restProps, ['children', 'defaultValue', 'value', 'onChange', 'disabled']);
+      var children = props.children;
+
+      if (options && options.length > 0) {
+        children = _this.getOptions().map(function (option) {
+          return /*#__PURE__*/React.createElement(Checkbox, {
+            prefixCls: prefixCls,
+            key: option.value.toString(),
+            disabled: 'disabled' in option ? option.disabled : props.disabled,
+            value: option.value,
+            checked: state.value.indexOf(option.value) !== -1,
+            onChange: option.onChange,
+            className: "".concat(groupPrefixCls, "-item")
+          }, option.label);
+        });
+      }
+
+      var classString = classNames(groupPrefixCls, className);
+      return /*#__PURE__*/React.createElement("div", _extends({
+        className: classString,
+        style: style
+      }, domProps), children);
+    };
+
+    _this.state = {
+      value: props.value || props.defaultValue || [],
+      registeredValues: []
+    };
+    return _this;
+  }
+
+  _createClass(CheckboxGroup, [{
+    key: "getChildContext",
+    value: function getChildContext() {
+      return {
+        checkboxGroup: {
+          toggleOption: this.toggleOption,
+          value: this.state.value,
+          disabled: this.props.disabled,
+          name: this.props.name,
+          // https://github.com/ant-design/ant-design/issues/16376
+          registerValue: this.registerValue,
+          cancelValue: this.cancelValue
+        }
+      };
+    }
+  }, {
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(nextProps, nextState) {
+      return !shallowEqual(this.props, nextProps) || !shallowEqual(this.state, nextState);
+    }
+  }, {
+    key: "getOptions",
+    value: function getOptions() {
+      var options = this.props.options; // https://github.com/Microsoft/TypeScript/issues/7960
+
+      return options.map(function (option) {
+        if (typeof option === 'string') {
+          return {
+            label: option,
+            value: option
+          };
+        }
+
+        return option;
+      });
+    }
+  }, {
+    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 || []
+        };
+      }
+
+      return null;
+    }
+  }]);
+
+  return CheckboxGroup;
+}(React.Component);
+
+CheckboxGroup.defaultProps = {
+  options: []
+};
+CheckboxGroup.propTypes = {
+  defaultValue: propTypesExports.array,
+  value: propTypesExports.array,
+  options: propTypesExports.array.isRequired,
+  onChange: propTypesExports.func
+};
+CheckboxGroup.childContextTypes = {
+  checkboxGroup: propTypesExports.any
+};
+polyfill(CheckboxGroup);
+
+Checkbox.Group = CheckboxGroup;
+
+export { Checkbox as C };

package/dist/index9.js

@@ -0,0 +1,130 @@
+import { D as Dropdown } from './dropdown.js';
+import * as React from 'react';
+import { c as classNames, C as ConfigConsumer } from './config-provider.js';
+import { B as Button } from './index7.js';
+import { I as Icon } from './icon.js';
+
+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 ButtonGroup = Button.Group;
+
+var DropdownButton = /*#__PURE__*/function (_React$Component) {
+  _inherits(DropdownButton, _React$Component);
+
+  var _super = _createSuper(DropdownButton);
+
+  function DropdownButton() {
+    var _this;
+
+    _classCallCheck(this, DropdownButton);
+
+    _this = _super.apply(this, arguments);
+
+    _this.renderButton = function (_ref) {
+      var getContextPopupContainer = _ref.getPopupContainer,
+          getPrefixCls = _ref.getPrefixCls;
+
+      var _a = _this.props,
+          customizePrefixCls = _a.prefixCls,
+          type = _a.type,
+          disabled = _a.disabled,
+          onClick = _a.onClick,
+          htmlType = _a.htmlType,
+          children = _a.children,
+          className = _a.className,
+          overlay = _a.overlay,
+          trigger = _a.trigger,
+          align = _a.align,
+          visible = _a.visible,
+          onVisibleChange = _a.onVisibleChange,
+          placement = _a.placement,
+          getPopupContainer = _a.getPopupContainer,
+          href = _a.href,
+          _a$icon = _a.icon,
+          icon = _a$icon === void 0 ? /*#__PURE__*/React.createElement(Icon, {
+        type: "ellipsis"
+      }) : _a$icon,
+          title = _a.title,
+          restProps = __rest(_a, ["prefixCls", "type", "disabled", "onClick", "htmlType", "children", "className", "overlay", "trigger", "align", "visible", "onVisibleChange", "placement", "getPopupContainer", "href", "icon", "title"]);
+
+      var prefixCls = getPrefixCls('dropdown-button', customizePrefixCls);
+      var dropdownProps = {
+        align: align,
+        overlay: overlay,
+        disabled: disabled,
+        trigger: disabled ? [] : trigger,
+        onVisibleChange: onVisibleChange,
+        placement: placement,
+        getPopupContainer: getPopupContainer || getContextPopupContainer
+      };
+
+      if ('visible' in _this.props) {
+        dropdownProps.visible = visible;
+      }
+
+      return /*#__PURE__*/React.createElement(ButtonGroup, _extends({}, restProps, {
+        className: classNames(prefixCls, className)
+      }), /*#__PURE__*/React.createElement(Button, {
+        type: type,
+        disabled: disabled,
+        onClick: onClick,
+        htmlType: htmlType,
+        href: href,
+        title: title
+      }, children), /*#__PURE__*/React.createElement(Dropdown, dropdownProps, /*#__PURE__*/React.createElement(Button, {
+        type: type
+      }, icon)));
+    };
+
+    return _this;
+  }
+
+  _createClass(DropdownButton, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderButton);
+    }
+  }]);
+
+  return DropdownButton;
+}(React.Component);
+DropdownButton.defaultProps = {
+  placement: 'bottomRight',
+  type: 'default'
+};
+
+Dropdown.Button = DropdownButton;