text: 'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');
  
  var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
  
  var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
  
  var _defineProperty3 = _interopRequireDefault(_defineProperty2);
  
  var _extends4 = require('babel-runtime/helpers/extends');
  
  var _extends5 = _interopRequireDefault(_extends4);
  
  exports.saveRef = saveRef;
  exports.getActiveKey = getActiveKey;
  
  var _omit = require('omit.js');
  
  var _omit2 = _interopRequireDefault(_omit);
  
  var _vueTypes = require('../_util/vue-types');
  
  var _vueTypes2 = _interopRequireDefault(_vueTypes);
  
  var _store = require('../_util/store');
  
  var _BaseMixin = require('../_util/BaseMixin');
  
  var _BaseMixin2 = _interopRequireDefault(_BaseMixin);
  
  var _KeyCode = require('../_util/KeyCode');
  
  var _KeyCode2 = _interopRequireDefault(_KeyCode);
  
  var _classnames = require('classnames');
  
  var _classnames2 = _interopRequireDefault(_classnames);
  
  var _util = require('./util');
  
  var _DOMWrap = require('./DOMWrap');
  
  var _DOMWrap2 = _interopRequireDefault(_DOMWrap);
  
  var _vnode = require('../_util/vnode');
  
  var _propsUtil = require('../_util/props-util');
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  function allDisabled(arr) {
    if (!arr.length) {
      return true;
    }
    return arr.every(function (c) {
      return !!c.disabled;
    });
  }
  
  function updateActiveKey(store, menuId, activeKey) {
    var state = store.getState();
    store.setState({
      activeKey: (0, _extends5['default'])({}, state.activeKey, (0, _defineProperty3['default'])({}, menuId, activeKey))
    });
  }
  
  function saveRef(key, c) {
    if (c) {
      var index = this.instanceArrayKeyIndexMap[key];
      this.instanceArray[index] = c;
      // const 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)
      // }
    }
  }
  function getActiveKey(props, originalActiveKey) {
    var activeKey = originalActiveKey;
    var eventKey = props.eventKey,
        defaultActiveFirst = props.defaultActiveFirst,
        children = props.children;
  
    if (activeKey !== undefined && activeKey !== null) {
      var found = void 0;
      (0, _util.loopMenuItem)(children, function (c, i) {
        var propsData = c.componentOptions.propsData || {};
        if (c && !propsData.disabled && activeKey === (0, _util.getKeyFromChildrenIndex)(c, eventKey, i)) {
          found = true;
        }
      });
      if (found) {
        return activeKey;
      }
    }
    activeKey = null;
    if (defaultActiveFirst) {
      (0, _util.loopMenuItem)(children, function (c, i) {
        var propsData = c.componentOptions.propsData || {};
        if (!activeKey && c && !propsData.disabled) {
          activeKey = (0, _util.getKeyFromChildrenIndex)(c, eventKey, i);
        }
      });
      return activeKey;
    }
    return activeKey;
  }
  
  var SubPopupMenu = {
    name: 'SubPopupMenu',
    props: (0, _propsUtil.initDefaultProps)({
      // onSelect: PropTypes.func,
      // onClick: PropTypes.func,
      // onDeselect: PropTypes.func,
      // onOpenChange: PropTypes.func,
      // onDestroy: PropTypes.func,
      prefixCls: _vueTypes2['default'].string,
      openTransitionName: _vueTypes2['default'].string,
      openAnimation: _vueTypes2['default'].oneOfType([_vueTypes2['default'].string, _vueTypes2['default'].object]),
      openKeys: _vueTypes2['default'].arrayOf(_vueTypes2['default'].oneOfType([_vueTypes2['default'].string, _vueTypes2['default'].number])),
      visible: _vueTypes2['default'].bool,
      parentMenu: _vueTypes2['default'].object,
      eventKey: _vueTypes2['default'].string,
      store: _vueTypes2['default'].object,
  
      // adding in refactor
      focusable: _vueTypes2['default'].bool,
      multiple: _vueTypes2['default'].bool,
      defaultActiveFirst: _vueTypes2['default'].bool,
      activeKey: _vueTypes2['default'].oneOfType([_vueTypes2['default'].string, _vueTypes2['default'].number]),
      selectedKeys: _vueTypes2['default'].arrayOf(_vueTypes2['default'].oneOfType([_vueTypes2['default'].string, _vueTypes2['default'].number])),
      defaultSelectedKeys: _vueTypes2['default'].arrayOf(_vueTypes2['default'].oneOfType([_vueTypes2['default'].string, _vueTypes2['default'].number])),
      defaultOpenKeys: _vueTypes2['default'].arrayOf(_vueTypes2['default'].oneOfType([_vueTypes2['default'].string, _vueTypes2['default'].number])),
      level: _vueTypes2['default'].number,
      mode: _vueTypes2['default'].oneOf(['horizontal', 'vertical', 'vertical-left', 'vertical-right', 'inline']),
      triggerSubMenuAction: _vueTypes2['default'].oneOf(['click', 'hover']),
      inlineIndent: _vueTypes2['default'].oneOfType([_vueTypes2['default'].number, _vueTypes2['default'].string]),
      manualRef: _vueTypes2['default'].func,
      children: _vueTypes2['default'].any.def([]),
      __propsSymbol__: _vueTypes2['default'].any // mock componentWillReceiveProps
    }, {
      prefixCls: 'rc-menu',
      mode: 'vertical',
      level: 1,
      inlineIndent: 24,
      visible: true,
      focusable: true,
      manualRef: _util.noop
    }),
  
    mixins: [_BaseMixin2['default']],
    created: function created() {
      var props = this.$props;
      props.store.setState({
        activeKey: (0, _extends5['default'])({}, props.store.getState().activeKey, (0, _defineProperty3['default'])({}, props.eventKey, getActiveKey(props, props.activeKey)))
      });
      this.instanceArray = [];
    },
    mounted: function mounted() {
      // invoke customized ref to expose component to mixin
      if (this.manualRef) {
        this.manualRef(this);
      }
    },
  
    watch: {
      __propsSymbol__: function __propsSymbol__() {
        var props = (0, _propsUtil.getOptionProps)(this);
        var storeActiveKey = this.getStore().getState().activeKey[this.getEventKey()];
        var originalActiveKey = 'activeKey' in props ? props.activeKey : storeActiveKey;
        var activeKey = getActiveKey(props, originalActiveKey);
        if (activeKey !== originalActiveKey || storeActiveKey !== activeKey) {
          updateActiveKey(this.getStore(), this.getEventKey(), activeKey);
        }
      }
    },
    methods: {
      // all keyboard events callbacks run from here at first
      onKeyDown: function onKeyDown(e, callback) {
        var keyCode = e.keyCode;
        var handled = void 0;
        this.getFlatInstanceArray().forEach(function (obj) {
          if (obj && obj.active && obj.onKeyDown) {
            handled = obj.onKeyDown(e);
          }
        });
        if (handled) {
          return 1;
        }
        var activeItem = null;
        if (keyCode === _KeyCode2['default'].UP || keyCode === _KeyCode2['default'].DOWN) {
          activeItem = this.step(keyCode === _KeyCode2['default'].UP ? -1 : 1);
        }
        if (activeItem) {
          e.preventDefault();
          updateActiveKey(this.getStore(), this.getEventKey(), activeItem.eventKey);
  
          if (typeof callback === 'function') {
            callback(activeItem);
          }
  
          return 1;
        }
      },
      onItemHover: function onItemHover(e) {
        var key = e.key,
            hover = e.hover;
  
        updateActiveKey(this.getStore(), this.getEventKey(), hover ? key : null);
      },
      onDeselect: function onDeselect(selectInfo) {
        this.__emit('deselect', selectInfo);
      },
      onSelect: function onSelect(selectInfo) {
        this.__emit('select', selectInfo);
      },
      onClick: function onClick(e) {
        this.__emit('click', e);
      },
      onOpenChange: function onOpenChange(e) {
        this.__emit('openChange', e);
      },
      onDestroy: function onDestroy(key) {
        this.__emit('destroy', key);
      },
      getFlatInstanceArray: function getFlatInstanceArray() {
        return this.instanceArray;
      },
      getStore: function getStore() {
        return this.store;
      },
      getEventKey: function getEventKey() {
        // when eventKey not available ,it's menu and return menu id '0-menu-'
        return this.eventKey !== undefined ? this.eventKey : '0-menu-';
      },
      getOpenTransitionName: function getOpenTransitionName() {
        return this.$props.openTransitionName;
      },
      step: function step(direction) {
        var children = this.getFlatInstanceArray();
        var activeKey = this.getStore().getState().activeKey[this.getEventKey()];
        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.eventKey === activeKey) {
            activeIndex = ci;
            return false;
          }
          return true;
        });
        if (!this.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.disabled) {
            i = (i + 1) % len;
          } else {
            return child;
          }
        } while (i !== start);
  
        return null;
      },
      renderCommonMenuItem: function renderCommonMenuItem(child, i, extraProps) {
        var _this = this;
  
        if (child.tag === undefined) {
          return child;
        }
        var state = this.getStore().getState();
        var props = this.$props;
        var key = (0, _util.getKeyFromChildrenIndex)(child, props.eventKey, i);
        var childProps = child.componentOptions.propsData || {};
        var isActive = key === state.activeKey[this.getEventKey()];
        if (!childProps.disabled) {
          // manualRef的执行顺序不能保证，使用key映射ref在this.instanceArray中的位置
          this.instanceArrayKeyIndexMap[key] = Object.keys(this.instanceArrayKeyIndexMap).length;
        }
        var childListeners = (0, _propsUtil.getEvents)(child);
        var newChildProps = {
          props: (0, _extends5['default'])({
            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 ? _util.noop : saveRef.bind(this, key),
            eventKey: key,
            active: !childProps.disabled && isActive,
            multiple: props.multiple,
            openTransitionName: this.getOpenTransitionName(),
            openAnimation: props.openAnimation,
            subMenuOpenDelay: props.subMenuOpenDelay,
            subMenuCloseDelay: props.subMenuCloseDelay,
            forceSubMenuRender: props.forceSubMenuRender
          }, extraProps),
          on: {
            click: function click(e) {
              (childListeners.click || _util.noop)(e);
              _this.onClick(e);
            },
            itemHover: this.onItemHover,
            openChange: this.onOpenChange,
            deselect: this.onDeselect,
            // destroy: this.onDestroy,
            select: this.onSelect
          }
        };
        if (props.mode === 'inline') {
          newChildProps.props.triggerSubMenuAction = 'click';
        }
        return (0, _vnode.cloneElement)(child, newChildProps);
      },
      renderMenuItem: function renderMenuItem(c, i, subMenuKey) {
        if (!c) {
          return null;
        }
        var state = this.getStore().getState();
        var extraProps = {
          openKeys: state.openKeys,
          selectedKeys: state.selectedKeys,
          triggerSubMenuAction: this.triggerSubMenuAction,
          isRootMenu: false,
          subMenuKey: subMenuKey
        };
        return this.renderCommonMenuItem(c, i, extraProps);
      }
    },
    render: function render() {
      var _this2 = this;
  
      var h = arguments[0];
      var props = (0, _objectWithoutProperties3['default'])(this.$props, []);
      var eventKey = props.eventKey,
          visible = props.visible;
  
      this.instanceArray = [];
      this.instanceArrayKeyIndexMap = {};
      var className = (0, _classnames2['default'])(props.prefixCls, props.prefixCls + '-' + props.mode);
      var domWrapProps = {
        props: {
          tag: 'ul',
          // hiddenClassName: `${prefixCls}-hidden`,
          visible: visible
        },
        attrs: {
          role: props.role || 'menu'
        },
        'class': className,
        // Otherwise, the propagated click event will trigger another onClick
        on: (0, _omit2['default'])(this.$listeners || {}, ['click'])
        // if (props.id) {
        //   domProps.id = props.id
        // }
      };if (props.focusable) {
        domWrapProps.attrs.tabIndex = '0';
        domWrapProps.on.keydown = this.onKeyDown;
      }
      return (
        // ESLint is not smart enough to know that the type of `children` was checked.
        /* eslint-disable */
        h(
          _DOMWrap2['default'],
          domWrapProps,
          [props.children.map(function (c, i) {
            return _this2.renderMenuItem(c, i, eventKey || '0-menu-');
          })]
        )
        /*eslint -enable */
  
      );
    }
  };
  
  exports['default'] = (0, _store.connect)()(SubPopupMenu);