choerodon-ui/es/rc-components/menu/SubPopupMenu.js

An enterprise-class UI design language and React-based implementation

import _typeof from "@babel/runtime/helpers/typeof";
import _extends from "@babel/runtime/helpers/extends";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
import _inherits from "@babel/runtime/helpers/inherits";
import _createSuper from "@babel/runtime/helpers/createSuper";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _objectSpread from "@babel/runtime/helpers/objectSpread2";
import React, { Children, cloneElement, Component } from 'react';
import classNames from 'classnames';
import noop from 'lodash/noop';
import { connect } from 'mini-store';
import KeyCode from '../../_util/KeyCode';
import createChainedFunction from '../util/createChainedFunction';
import { getKeyFromChildrenIndex, loopMenuItem, menuAllProps } from './util';
import DOMWrap from './DOMWrap';

function allDisabled(arr) {
  if (!arr.length) {
    return true;
  }

  return arr.every(function (c) {
    return !!c.props.disabled;
  });
}

function updateActiveKey(store, menuId, activeKey) {
  var state = store.getState();
  store.setState({
    activeKey: _objectSpread(_objectSpread({}, state.activeKey), {}, _defineProperty({}, menuId, activeKey))
  });
}

function getEventKey(props) {
  // when eventKey not available ,it's menu and return menu id '0-menu-'
  return props.eventKey || '0-menu-';
}

export function getActiveKey(props, originalActiveKey) {
  var activeKey = originalActiveKey;
  var children = props.children,
      eventKey = props.eventKey;

  if (activeKey) {
    var found;
    loopMenuItem(children, function (c, i) {
      if (c && !c.props.disabled && activeKey === getKeyFromChildrenIndex(c, eventKey, i)) {
        found = true;
      }
    });

    if (found) {
      return activeKey;
    }
  }

  activeKey = null;

  if (props.defaultActiveFirst) {
    loopMenuItem(children, function (c, i) {
      if (!activeKey && c && !c.props.disabled) {
        activeKey = getKeyFromChildrenIndex(c, eventKey, i);
      }
    });
    return activeKey;
  }

  return activeKey;
}
export function saveRef(c) {
  if (c) {
    var index = this.instanceArray.indexOf(c);

    if (index !== -1) {
      // update component if it's already inside instanceArray
      this.instanceArray[index] = c;
    } else {
      // add component if it's not in instanceArray yet;
      this.instanceArray.push(c);
    }
  }
}
export function getWrappedInstance() {
  return SubPopupMenu;
}
export var SubPopupMenu = /*#__PURE__*/function (_Component) {
  _inherits(SubPopupMenu, _Component);

  var _super = _createSuper(SubPopupMenu);

  function SubPopupMenu(_props) {
    var _this;

    _classCallCheck(this, SubPopupMenu);

    _this = _super.call(this, _props);

    _defineProperty(_assertThisInitialized(_this), "onKeyDown", function (e, callback) {
      var keyCode = e.keyCode;
      var handled;

      _this.getFlatInstanceArray().forEach(function (obj) {
        if (obj && obj.props.active && obj.onKeyDown) {
          handled = obj.onKeyDown(e);
        }
      });

      if (handled) {
        return 1;
      }

      var activeItem = null;

      if (keyCode === KeyCode.UP || keyCode === KeyCode.DOWN) {
        activeItem = _this.step(keyCode === KeyCode.UP ? -1 : 1);
      }

      if (activeItem) {
        e.preventDefault();
        updateActiveKey(_this.props.store, getEventKey(_this.props), activeItem.props.eventKey);

        if (typeof callback === 'function') {
          callback(activeItem);
        }

        return 1;
      }
    });

    _defineProperty(_assertThisInitialized(_this), "onItemHover", function (e) {
      var key = e.key,
          hover = e.hover;
      updateActiveKey(_this.props.store, getEventKey(_this.props), hover ? key : null);
    });

    _defineProperty(_assertThisInitialized(_this), "onDeselect", function (selectInfo) {
      _this.props.onDeselect(selectInfo);
    });

    _defineProperty(_assertThisInitialized(_this), "onSelect", function (selectInfo) {
      _this.props.onSelect(selectInfo);
    });

    _defineProperty(_assertThisInitialized(_this), "onClick", function (e) {
      _this.props.onClick(e);
    });

    _defineProperty(_assertThisInitialized(_this), "onOpenChange", function (e) {
      _this.props.onOpenChange(e);
    });

    _defineProperty(_assertThisInitialized(_this), "onDestroy", function (key) {
      /* istanbul ignore next */
      _this.props.onDestroy(key);
    });

    _defineProperty(_assertThisInitialized(_this), "getFlatInstanceArray", function () {
      return _this.instanceArray;
    });

    _defineProperty(_assertThisInitialized(_this), "getOpenTransitionName", function () {
      return _this.props.openTransitionName;
    });

    _defineProperty(_assertThisInitialized(_this), "step", function (direction) {
      var children = _this.getFlatInstanceArray();

      var activeKey = _this.props.store.getState().activeKey[getEventKey(_this.props)];

      var len = children.length;

      if (!len) {
        return null;
      }

      if (direction < 0) {
        children = children.concat().reverse();
      } // find current activeIndex


      var activeIndex = -1;
      children.every(function (c, ci) {
        if (c && c.props.eventKey === activeKey) {
          activeIndex = ci;
          return false;
        }

        return true;
      });

      if (!_this.props.defaultActiveFirst && activeIndex !== -1 && allDisabled(children.slice(activeIndex, len - 1))) {
        return undefined;
      }

      var start = (activeIndex + 1) % len;
      var i = start;

      do {
        var child = children[i];

        if (!child || child.props.disabled) {
          i = (i + 1) % len;
        } else {
          return child;
        }
      } while (i !== start);

      return null;
    });

    _defineProperty(_assertThisInitialized(_this), "renderCommonMenuItem", function (child, i, extraProps) {
      var state = _this.props.store.getState();

      var props = _this.props;
      var key = getKeyFromChildrenIndex(child, props.eventKey, i);
      var childProps = child.props;
      var isActive = key === state.activeKey;

      var newChildProps = _objectSpread({
        mode: childProps.mode || props.mode,
        level: props.level,
        inlineIndent: props.inlineIndent,
        renderMenuItem: _this.renderMenuItem,
        rootPrefixCls: props.prefixCls,
        index: i,
        parentMenu: props.parentMenu,
        // customized ref function, need to be invoked manually in child's componentDidMount
        manualRef: childProps.disabled ? undefined : createChainedFunction(child.ref, saveRef.bind(_assertThisInitialized(_this))),
        eventKey: key,
        active: !childProps.disabled && isActive,
        multiple: props.multiple,
        rippleDisabled: props.rippleDisabled,
        onClick: function onClick(e) {
          (childProps.onClick || noop)(e);

          _this.onClick(e);
        },
        onItemHover: _this.onItemHover,
        openTransitionName: _this.getOpenTransitionName(),
        openAnimation: props.openAnimation,
        subMenuOpenDelay: props.subMenuOpenDelay,
        subMenuCloseDelay: props.subMenuCloseDelay,
        forceSubMenuRender: props.forceSubMenuRender,
        onOpenChange: _this.onOpenChange,
        onDeselect: _this.onDeselect,
        onSelect: _this.onSelect,
        builtinPlacements: props.builtinPlacements,
        itemIcon: childProps.itemIcon || _this.props.itemIcon,
        expandIcon: childProps.expandIcon || _this.props.expandIcon
      }, extraProps);

      if (props.mode === 'inline') {
        newChildProps.triggerSubMenuAction = 'click';
      }

      return /*#__PURE__*/cloneElement(child, newChildProps);
    });

    _defineProperty(_assertThisInitialized(_this), "renderMenuItem", function (c, i, subMenuKey) {
      /* istanbul ignore if */
      if (!c) {
        return null;
      }

      var props = _this.props;
      var extraProps = {
        openKeys: props.openKeys,
        selectedKeys: props.selectedKeys,
        triggerSubMenuAction: props.triggerSubMenuAction,
        subMenuKey: subMenuKey
      };
      return _this.renderCommonMenuItem(c, i, extraProps);
    });

    _props.store.setState({
      activeKey: _objectSpread(_objectSpread({}, _props.store.getState().activeKey), {}, _defineProperty({}, _props.eventKey, getActiveKey(_props, _props.activeKey)))
    });

    _this.instanceArray = [];
    return _this;
  }

  _createClass(SubPopupMenu, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      // invoke customized ref to expose component to mixin
      if (this.props.manualRef) {
        this.props.manualRef(this);
      }
    }
  }, {
    key: "shouldComponentUpdate",
    value: function shouldComponentUpdate(nextProps) {
      return !this.props.hidden || !nextProps.hidden;
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate() {
      var props = this.props;
      var originalActiveKey = 'activeKey' in props ? props.activeKey : props.store.getState().activeKey[getEventKey(props)];
      var activeKey = getActiveKey(props, originalActiveKey);

      if (activeKey !== originalActiveKey) {
        updateActiveKey(props.store, getEventKey(props), activeKey);
      }
    } // all keyboard events callbacks run from here at first

  }, {
    key: "render",
    value: function render() {
      var _this2 = this;

      var props = _extends({}, this.props);

      this.instanceArray = [];
      var className = classNames(props.prefixCls, props.className, "".concat(props.prefixCls, "-").concat(props.mode));
      var haveRendered = this.haveRendered;
      this.haveRendered = true;
      this.haveOpened = this.haveOpened || !props.hidden || props.forceSubMenuRender;

      if (!this.haveOpened) {
        return null;
      }

      var domProps = {
        className: className,
        // role could be 'select' and by default set to menu
        role: props.role || 'menu'
      };

      if (props.id) {
        domProps.id = props.id;
      }

      if (props.focusable) {
        domProps.tabIndex = '0';
        domProps.onKeyDown = this.onKeyDown;
      }

      var prefixCls = props.prefixCls,
          eventKey = props.eventKey,
          hidden = props.hidden,
          level = props.level,
          mode = props.mode,
          overflowedIndicator = props.overflowedIndicator,
          theme = props.theme;
      menuAllProps.forEach(function (key) {
        return delete props[key];
      });
      var transitionAppear = !(!haveRendered && !props.hidden && props.mode === 'inline');
      props.className += " ".concat(props.prefixCls, "-sub");
      delete props.onClick;
      var animProps = {};

      if (props.openTransitionName) {
        animProps.transitionName = props.openTransitionName;
      } else if (_typeof(props.openAnimation) === 'object') {
        animProps.animation = _objectSpread({}, props.openAnimation);

        if (!transitionAppear) {
          delete animProps.animation.appear;
        }
      }

      return (
        /*#__PURE__*/

        /* eslint-disable */
        React.createElement(DOMWrap, _extends({}, props, {
          prefixCls: prefixCls,
          mode: mode,
          tag: "ul",
          level: level,
          theme: theme,
          hiddenClassName: "".concat(prefixCls, "-hidden"),
          hidden: hidden,
          overflowedIndicator: overflowedIndicator
        }, domProps), Children.map(props.children, function (c, i) {
          return _this2.renderMenuItem(c, i, eventKey || '0-menu-');
        }))
        /*eslint-enable */

      );
    }
  }]);

  return SubPopupMenu;
}(Component);

_defineProperty(SubPopupMenu, "defaultProps", {
  prefixCls: 'rc-menu',
  className: '',
  mode: 'vertical',
  level: 1,
  inlineIndent: 24,
  hidden: false,
  focusable: true,
  style: {},
  manualRef: noop
});

var connected = connect()(SubPopupMenu);
export default connected;
//# sourceMappingURL=SubPopupMenu.js.map