antd3-esm 1.0.1

package/dist/dropdown.js

@@ -0,0 +1,442 @@
+import * as React from 'react';
+import React__default, { cloneElement, Component } from 'react';
+import { c as classNames, P as PropTypes, C as ConfigConsumer } from './config-provider.js';
+import ReactDOM__default from 'react-dom';
+import { b as Trigger, p as polyfill } from './menu.js';
+import { I as Icon } from './icon.js';
+import { t as tuple } from './input.js';
+
+var autoAdjustOverflow = {
+  adjustX: 1,
+  adjustY: 1
+};
+
+var targetOffset = [0, 0];
+
+var placements = {
+  topLeft: {
+    points: ['bl', 'tl'],
+    overflow: autoAdjustOverflow,
+    offset: [0, -4],
+    targetOffset: targetOffset
+  },
+  topCenter: {
+    points: ['bc', 'tc'],
+    overflow: autoAdjustOverflow,
+    offset: [0, -4],
+    targetOffset: targetOffset
+  },
+  topRight: {
+    points: ['br', 'tr'],
+    overflow: autoAdjustOverflow,
+    offset: [0, -4],
+    targetOffset: targetOffset
+  },
+  bottomLeft: {
+    points: ['tl', 'bl'],
+    overflow: autoAdjustOverflow,
+    offset: [0, 4],
+    targetOffset: targetOffset
+  },
+  bottomCenter: {
+    points: ['tc', 'bc'],
+    overflow: autoAdjustOverflow,
+    offset: [0, 4],
+    targetOffset: targetOffset
+  },
+  bottomRight: {
+    points: ['tr', 'br'],
+    overflow: autoAdjustOverflow,
+    offset: [0, 4],
+    targetOffset: targetOffset
+  }
+};
+
+var _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; };
+
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+
+function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn$1(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits$1(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Dropdown$1 = function (_Component) {
+  _inherits$1(Dropdown, _Component);
+
+  function Dropdown(props) {
+    _classCallCheck$1(this, Dropdown);
+
+    var _this = _possibleConstructorReturn$1(this, _Component.call(this, props));
+
+    _initialiseProps.call(_this);
+
+    if ('visible' in props) {
+      _this.state = {
+        visible: props.visible
+      };
+    } else {
+      _this.state = {
+        visible: props.defaultVisible
+      };
+    }
+    return _this;
+  }
+
+  Dropdown.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps) {
+    if ('visible' in nextProps) {
+      return {
+        visible: nextProps.visible
+      };
+    }
+    return null;
+  };
+
+  Dropdown.prototype.getOverlayElement = function getOverlayElement() {
+    var overlay = this.props.overlay;
+
+    var overlayElement = void 0;
+    if (typeof overlay === 'function') {
+      overlayElement = overlay();
+    } else {
+      overlayElement = overlay;
+    }
+    return overlayElement;
+  };
+
+  Dropdown.prototype.getMenuElementOrLambda = function getMenuElementOrLambda() {
+    var overlay = this.props.overlay;
+
+    if (typeof overlay === 'function') {
+      return this.getMenuElement;
+    }
+    return this.getMenuElement();
+  };
+
+  Dropdown.prototype.getPopupDomNode = function getPopupDomNode() {
+    return this.trigger.getPopupDomNode();
+  };
+
+  Dropdown.prototype.getOpenClassName = function getOpenClassName() {
+    var _props = this.props,
+        openClassName = _props.openClassName,
+        prefixCls = _props.prefixCls;
+
+    if (openClassName !== undefined) {
+      return openClassName;
+    }
+    return prefixCls + '-open';
+  };
+
+  Dropdown.prototype.renderChildren = function renderChildren() {
+    var children = this.props.children;
+    var visible = this.state.visible;
+
+    var childrenProps = children.props ? children.props : {};
+    var childClassName = classNames(childrenProps.className, this.getOpenClassName());
+    return visible && children ? cloneElement(children, { className: childClassName }) : children;
+  };
+
+  Dropdown.prototype.render = function render() {
+    var _props2 = this.props,
+        prefixCls = _props2.prefixCls,
+        transitionName = _props2.transitionName,
+        animation = _props2.animation,
+        align = _props2.align,
+        placement = _props2.placement,
+        getPopupContainer = _props2.getPopupContainer,
+        showAction = _props2.showAction,
+        hideAction = _props2.hideAction,
+        overlayClassName = _props2.overlayClassName,
+        overlayStyle = _props2.overlayStyle,
+        trigger = _props2.trigger,
+        otherProps = _objectWithoutProperties(_props2, ['prefixCls', 'transitionName', 'animation', 'align', 'placement', 'getPopupContainer', 'showAction', 'hideAction', 'overlayClassName', 'overlayStyle', 'trigger']);
+
+    var triggerHideAction = hideAction;
+    if (!triggerHideAction && trigger.indexOf('contextMenu') !== -1) {
+      triggerHideAction = ['click'];
+    }
+
+    return React__default.createElement(
+      Trigger,
+      _extends$1({}, otherProps, {
+        prefixCls: prefixCls,
+        ref: this.saveTrigger,
+        popupClassName: overlayClassName,
+        popupStyle: overlayStyle,
+        builtinPlacements: placements,
+        action: trigger,
+        showAction: showAction,
+        hideAction: triggerHideAction || [],
+        popupPlacement: placement,
+        popupAlign: align,
+        popupTransitionName: transitionName,
+        popupAnimation: animation,
+        popupVisible: this.state.visible,
+        afterPopupVisibleChange: this.afterVisibleChange,
+        popup: this.getMenuElementOrLambda(),
+        onPopupVisibleChange: this.onVisibleChange,
+        getPopupContainer: getPopupContainer
+      }),
+      this.renderChildren()
+    );
+  };
+
+  return Dropdown;
+}(Component);
+
+Dropdown$1.propTypes = {
+  minOverlayWidthMatchTrigger: PropTypes.bool,
+  onVisibleChange: PropTypes.func,
+  onOverlayClick: PropTypes.func,
+  prefixCls: PropTypes.string,
+  children: PropTypes.any,
+  transitionName: PropTypes.string,
+  overlayClassName: PropTypes.string,
+  openClassName: PropTypes.string,
+  animation: PropTypes.any,
+  align: PropTypes.object,
+  overlayStyle: PropTypes.object,
+  placement: PropTypes.string,
+  overlay: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
+  trigger: PropTypes.array,
+  alignPoint: PropTypes.bool,
+  showAction: PropTypes.array,
+  hideAction: PropTypes.array,
+  getPopupContainer: PropTypes.func,
+  visible: PropTypes.bool,
+  defaultVisible: PropTypes.bool
+};
+Dropdown$1.defaultProps = {
+  prefixCls: 'rc-dropdown',
+  trigger: ['hover'],
+  showAction: [],
+  overlayClassName: '',
+  overlayStyle: {},
+  defaultVisible: false,
+  onVisibleChange: function onVisibleChange() {},
+
+  placement: 'bottomLeft'
+};
+
+var _initialiseProps = function _initialiseProps() {
+  var _this2 = this;
+
+  this.onClick = function (e) {
+    var props = _this2.props;
+    var overlayProps = _this2.getOverlayElement().props;
+    // do no call onVisibleChange, if you need click to hide, use onClick and control visible
+    if (!('visible' in props)) {
+      _this2.setState({
+        visible: false
+      });
+    }
+    if (props.onOverlayClick) {
+      props.onOverlayClick(e);
+    }
+    if (overlayProps.onClick) {
+      overlayProps.onClick(e);
+    }
+  };
+
+  this.onVisibleChange = function (visible) {
+    var props = _this2.props;
+    if (!('visible' in props)) {
+      _this2.setState({
+        visible: visible
+      });
+    }
+    props.onVisibleChange(visible);
+  };
+
+  this.getMinOverlayWidthMatchTrigger = function () {
+    var _props3 = _this2.props,
+        minOverlayWidthMatchTrigger = _props3.minOverlayWidthMatchTrigger,
+        alignPoint = _props3.alignPoint;
+
+    if ('minOverlayWidthMatchTrigger' in _this2.props) {
+      return minOverlayWidthMatchTrigger;
+    }
+
+    return !alignPoint;
+  };
+
+  this.getMenuElement = function () {
+    var prefixCls = _this2.props.prefixCls;
+
+    var overlayElement = _this2.getOverlayElement();
+    var extraOverlayProps = {
+      prefixCls: prefixCls + '-menu',
+      onClick: _this2.onClick
+    };
+    if (typeof overlayElement.type === 'string') {
+      delete extraOverlayProps.prefixCls;
+    }
+    return React__default.cloneElement(overlayElement, extraOverlayProps);
+  };
+
+  this.afterVisibleChange = function (visible) {
+    if (visible && _this2.getMinOverlayWidthMatchTrigger()) {
+      var overlayNode = _this2.getPopupDomNode();
+      var rootNode = ReactDOM__default.findDOMNode(_this2);
+      if (rootNode && overlayNode && rootNode.offsetWidth > overlayNode.offsetWidth) {
+        overlayNode.style.minWidth = rootNode.offsetWidth + 'px';
+        if (_this2.trigger && _this2.trigger._component && _this2.trigger._component.alignInstance) {
+          _this2.trigger._component.alignInstance.forceAlign();
+        }
+      }
+    }
+  };
+
+  this.saveTrigger = function (node) {
+    _this2.trigger = node;
+  };
+};
+
+polyfill(Dropdown$1);
+
+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); }
+tuple('topLeft', 'topCenter', 'topRight', 'bottomLeft', 'bottomCenter', 'bottomRight');
+
+var Dropdown = /*#__PURE__*/function (_React$Component) {
+  _inherits(Dropdown, _React$Component);
+
+  var _super = _createSuper(Dropdown);
+
+  function Dropdown() {
+    var _this;
+
+    _classCallCheck(this, Dropdown);
+
+    _this = _super.apply(this, arguments);
+
+    _this.renderOverlay = function (prefixCls) {
+      // rc-dropdown already can process the function of overlay, but we have check logic here.
+      // So we need render the element to check and pass back to rc-dropdown.
+      var overlay = _this.props.overlay;
+      var overlayNode;
+
+      if (typeof overlay === 'function') {
+        overlayNode = overlay();
+      } else {
+        overlayNode = overlay;
+      }
+
+      overlayNode = React.Children.only(overlayNode);
+      var overlayProps = overlayNode.props; // Warning if use other mode
+      // menu should be focusable in dropdown defaultly
+
+      var _overlayProps$selecta = overlayProps.selectable,
+          selectable = _overlayProps$selecta === void 0 ? false : _overlayProps$selecta,
+          _overlayProps$focusab = overlayProps.focusable,
+          focusable = _overlayProps$focusab === void 0 ? true : _overlayProps$focusab;
+      var expandIcon = /*#__PURE__*/React.createElement("span", {
+        className: "".concat(prefixCls, "-menu-submenu-arrow")
+      }, /*#__PURE__*/React.createElement(Icon, {
+        type: "right",
+        className: "".concat(prefixCls, "-menu-submenu-arrow-icon")
+      }));
+      var fixedModeOverlay = typeof overlayNode.type === 'string' ? overlay : /*#__PURE__*/React.cloneElement(overlayNode, {
+        mode: 'vertical',
+        selectable: selectable,
+        focusable: focusable,
+        expandIcon: expandIcon
+      });
+      return fixedModeOverlay;
+    };
+
+    _this.renderDropDown = function (_ref) {
+      var getContextPopupContainer = _ref.getPopupContainer,
+          getPrefixCls = _ref.getPrefixCls;
+      var _this$props = _this.props,
+          customizePrefixCls = _this$props.prefixCls,
+          children = _this$props.children,
+          trigger = _this$props.trigger,
+          disabled = _this$props.disabled,
+          getPopupContainer = _this$props.getPopupContainer;
+      var prefixCls = getPrefixCls('dropdown', customizePrefixCls);
+      var child = React.Children.only(children);
+      var dropdownTrigger = /*#__PURE__*/React.cloneElement(child, {
+        className: classNames(child.props.className, "".concat(prefixCls, "-trigger")),
+        disabled: disabled
+      });
+      var triggerActions = disabled ? [] : trigger;
+      var alignPoint;
+
+      if (triggerActions && triggerActions.indexOf('contextMenu') !== -1) {
+        alignPoint = true;
+      }
+
+      return /*#__PURE__*/React.createElement(Dropdown$1, _extends({
+        alignPoint: alignPoint
+      }, _this.props, {
+        prefixCls: prefixCls,
+        getPopupContainer: getPopupContainer || getContextPopupContainer,
+        transitionName: _this.getTransitionName(),
+        trigger: triggerActions,
+        overlay: function overlay() {
+          return _this.renderOverlay(prefixCls);
+        }
+      }), dropdownTrigger);
+    };
+
+    return _this;
+  }
+
+  _createClass(Dropdown, [{
+    key: "getTransitionName",
+    value: function getTransitionName() {
+      var _this$props2 = this.props,
+          _this$props2$placemen = _this$props2.placement,
+          placement = _this$props2$placemen === void 0 ? '' : _this$props2$placemen,
+          transitionName = _this$props2.transitionName;
+
+      if (transitionName !== undefined) {
+        return transitionName;
+      }
+
+      if (placement.indexOf('top') >= 0) {
+        return 'slide-down';
+      }
+
+      return 'slide-up';
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderDropDown);
+    }
+  }]);
+
+  return Dropdown;
+}(React.Component);
+Dropdown.defaultProps = {
+  mouseEnterDelay: 0.15,
+  mouseLeaveDelay: 0.1,
+  placement: 'bottomLeft'
+};
+
+export { Dropdown as D };