@laozei/element-ui 2.16.0

package/lib/menu.js

@@ -0,0 +1,864 @@
+module.exports =
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "/dist/";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 69);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return normalizeComponent; });
+/* globals __VUE_SSR_CONTEXT__ */
+
+// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
+// This module is a runtime utility for cleaner component module output and will
+// be included in the final webpack user bundle.
+
+function normalizeComponent (
+  scriptExports,
+  render,
+  staticRenderFns,
+  functionalTemplate,
+  injectStyles,
+  scopeId,
+  moduleIdentifier, /* server only */
+  shadowMode /* vue-cli only */
+) {
+  // Vue.extend constructor export interop
+  var options = typeof scriptExports === 'function'
+    ? scriptExports.options
+    : scriptExports
+
+  // render functions
+  if (render) {
+    options.render = render
+    options.staticRenderFns = staticRenderFns
+    options._compiled = true
+  }
+
+  // functional template
+  if (functionalTemplate) {
+    options.functional = true
+  }
+
+  // scopedId
+  if (scopeId) {
+    options._scopeId = 'data-v-' + scopeId
+  }
+
+  var hook
+  if (moduleIdentifier) { // server build
+    hook = function (context) {
+      // 2.3 injection
+      context =
+        context || // cached call
+        (this.$vnode && this.$vnode.ssrContext) || // stateful
+        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
+      // 2.2 with runInNewContext: true
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
+        context = __VUE_SSR_CONTEXT__
+      }
+      // inject component styles
+      if (injectStyles) {
+        injectStyles.call(this, context)
+      }
+      // register component module identifier for async chunk inferrence
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier)
+      }
+    }
+    // used by ssr in case component is cached and beforeCreate
+    // never gets called
+    options._ssrRegister = hook
+  } else if (injectStyles) {
+    hook = shadowMode
+      ? function () { injectStyles.call(this, this.$root.$options.shadowRoot) }
+      : injectStyles
+  }
+
+  if (hook) {
+    if (options.functional) {
+      // for template-only hot-reload because in that case the render fn doesn't
+      // go through the normalizer
+      options._injectStyles = hook
+      // register for functioal component in vue file
+      var originalRender = options.render
+      options.render = function renderWithStyleInjection (h, context) {
+        hook.call(context)
+        return originalRender(h, context)
+      }
+    } else {
+      // inject component registration as beforeCreate hook
+      var existing = options.beforeCreate
+      options.beforeCreate = existing
+        ? [].concat(existing, hook)
+        : [hook]
+    }
+  }
+
+  return {
+    exports: scriptExports,
+    options: options
+  }
+}
+
+
+/***/ }),
+
+/***/ 12:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/mixins/migrating");
+
+/***/ }),
+
+/***/ 2:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/dom");
+
+/***/ }),
+
+/***/ 4:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/mixins/emitter");
+
+/***/ }),
+
+/***/ 69:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+
+// EXTERNAL MODULE: external "element-ui/lib/mixins/emitter"
+var emitter_ = __webpack_require__(4);
+var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);
+
+// EXTERNAL MODULE: external "element-ui/lib/mixins/migrating"
+var migrating_ = __webpack_require__(12);
+var migrating_default = /*#__PURE__*/__webpack_require__.n(migrating_);
+
+// CONCATENATED MODULE: ./src/utils/aria-utils.js
+var aria = aria || {};
+
+aria.Utils = aria.Utils || {};
+
+/**
+ * @desc Set focus on descendant nodes until the first focusable element is
+ *       found.
+ * @param element
+ *          DOM node for which to find the first focusable descendant.
+ * @returns
+ *  true if a focusable element is found and focus is set.
+ */
+aria.Utils.focusFirstDescendant = function (element) {
+  for (var i = 0; i < element.childNodes.length; i++) {
+    var child = element.childNodes[i];
+    if (aria.Utils.attemptFocus(child) || aria.Utils.focusFirstDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * @desc Find the last descendant node that is focusable.
+ * @param element
+ *          DOM node for which to find the last focusable descendant.
+ * @returns
+ *  true if a focusable element is found and focus is set.
+ */
+
+aria.Utils.focusLastDescendant = function (element) {
+  for (var i = element.childNodes.length - 1; i >= 0; i--) {
+    var child = element.childNodes[i];
+    if (aria.Utils.attemptFocus(child) || aria.Utils.focusLastDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * @desc Set Attempt to set focus on the current node.
+ * @param element
+ *          The node to attempt to focus on.
+ * @returns
+ *  true if element is focused.
+ */
+aria.Utils.attemptFocus = function (element) {
+  if (!aria.Utils.isFocusable(element)) {
+    return false;
+  }
+  aria.Utils.IgnoreUtilFocusChanges = true;
+  try {
+    element.focus();
+  } catch (e) {}
+  aria.Utils.IgnoreUtilFocusChanges = false;
+  return document.activeElement === element;
+};
+
+aria.Utils.isFocusable = function (element) {
+  if (element.tabIndex > 0 || element.tabIndex === 0 && element.getAttribute('tabIndex') !== null) {
+    return true;
+  }
+
+  if (element.disabled) {
+    return false;
+  }
+
+  switch (element.nodeName) {
+    case 'A':
+      return !!element.href && element.rel !== 'ignore';
+    case 'INPUT':
+      return element.type !== 'hidden' && element.type !== 'file';
+    case 'BUTTON':
+    case 'SELECT':
+    case 'TEXTAREA':
+      return true;
+    default:
+      return false;
+  }
+};
+
+/**
+ * 触发一个事件
+ * mouseenter, mouseleave, mouseover, keyup, change, click 等
+ * @param  {Element} elm
+ * @param  {String} name
+ * @param  {*} opts
+ */
+aria.Utils.triggerEvent = function (elm, name) {
+  var eventName = void 0;
+
+  if (/^mouse|click/.test(name)) {
+    eventName = 'MouseEvents';
+  } else if (/^key/.test(name)) {
+    eventName = 'KeyboardEvent';
+  } else {
+    eventName = 'HTMLEvents';
+  }
+  var evt = document.createEvent(eventName);
+
+  for (var _len = arguments.length, opts = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    opts[_key - 2] = arguments[_key];
+  }
+
+  evt.initEvent.apply(evt, [name].concat(opts));
+  elm.dispatchEvent ? elm.dispatchEvent(evt) : elm.fireEvent('on' + name, evt);
+
+  return elm;
+};
+
+aria.Utils.keys = {
+  tab: 9,
+  enter: 13,
+  space: 32,
+  left: 37,
+  up: 38,
+  right: 39,
+  down: 40,
+  esc: 27
+};
+
+/* harmony default export */ var aria_utils = (aria.Utils);
+// CONCATENATED MODULE: ./src/utils/menu/aria-submenu.js
+
+
+var SubMenu = function SubMenu(parent, domNode) {
+  this.domNode = domNode;
+  this.parent = parent;
+  this.subMenuItems = [];
+  this.subIndex = 0;
+  this.init();
+};
+
+SubMenu.prototype.init = function () {
+  this.subMenuItems = this.domNode.querySelectorAll('li');
+  this.addListeners();
+};
+
+SubMenu.prototype.gotoSubIndex = function (idx) {
+  if (idx === this.subMenuItems.length) {
+    idx = 0;
+  } else if (idx < 0) {
+    idx = this.subMenuItems.length - 1;
+  }
+  this.subMenuItems[idx].focus();
+  this.subIndex = idx;
+};
+
+SubMenu.prototype.addListeners = function () {
+  var _this = this;
+
+  var keys = aria_utils.keys;
+  var parentNode = this.parent.domNode;
+  Array.prototype.forEach.call(this.subMenuItems, function (el) {
+    el.addEventListener('keydown', function (event) {
+      var prevDef = false;
+      switch (event.keyCode) {
+        case keys.down:
+          _this.gotoSubIndex(_this.subIndex + 1);
+          prevDef = true;
+          break;
+        case keys.up:
+          _this.gotoSubIndex(_this.subIndex - 1);
+          prevDef = true;
+          break;
+        case keys.tab:
+          aria_utils.triggerEvent(parentNode, 'mouseleave');
+          break;
+        case keys.enter:
+        case keys.space:
+          prevDef = true;
+          event.currentTarget.click();
+          break;
+      }
+      if (prevDef) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+      return false;
+    });
+  });
+};
+
+/* harmony default export */ var aria_submenu = (SubMenu);
+// CONCATENATED MODULE: ./src/utils/menu/aria-menuitem.js
+
+
+
+var MenuItem = function MenuItem(domNode) {
+  this.domNode = domNode;
+  this.submenu = null;
+  this.init();
+};
+
+MenuItem.prototype.init = function () {
+  this.domNode.setAttribute('tabindex', '0');
+  var menuChild = this.domNode.querySelector('.el-menu');
+  if (menuChild) {
+    this.submenu = new aria_submenu(this, menuChild);
+  }
+  this.addListeners();
+};
+
+MenuItem.prototype.addListeners = function () {
+  var _this = this;
+
+  var keys = aria_utils.keys;
+  this.domNode.addEventListener('keydown', function (event) {
+    var prevDef = false;
+    switch (event.keyCode) {
+      case keys.down:
+        aria_utils.triggerEvent(event.currentTarget, 'mouseenter');
+        _this.submenu && _this.submenu.gotoSubIndex(0);
+        prevDef = true;
+        break;
+      case keys.up:
+        aria_utils.triggerEvent(event.currentTarget, 'mouseenter');
+        _this.submenu && _this.submenu.gotoSubIndex(_this.submenu.subMenuItems.length - 1);
+        prevDef = true;
+        break;
+      case keys.tab:
+        aria_utils.triggerEvent(event.currentTarget, 'mouseleave');
+        break;
+      case keys.enter:
+      case keys.space:
+        prevDef = true;
+        event.currentTarget.click();
+        break;
+    }
+    if (prevDef) {
+      event.preventDefault();
+    }
+  });
+};
+
+/* harmony default export */ var aria_menuitem = (MenuItem);
+// CONCATENATED MODULE: ./src/utils/menu/aria-menubar.js
+
+
+var Menu = function Menu(domNode) {
+  this.domNode = domNode;
+  this.init();
+};
+
+Menu.prototype.init = function () {
+  var menuChildren = this.domNode.childNodes;
+  [].filter.call(menuChildren, function (child) {
+    return child.nodeType === 1;
+  }).forEach(function (child) {
+    new aria_menuitem(child); // eslint-disable-line
+  });
+};
+/* harmony default export */ var aria_menubar = (Menu);
+// EXTERNAL MODULE: external "element-ui/lib/utils/dom"
+var dom_ = __webpack_require__(2);
+
+// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/menu/src/menu.vue?vue&type=script&lang=js&
+
+
+
+
+
+
+/* harmony default export */ var menuvue_type_script_lang_js_ = ({
+  name: 'ElMenu',
+
+  render: function render(h) {
+    var component = h(
+      'ul',
+      {
+        attrs: {
+          role: 'menubar'
+        },
+        key: +this.collapse,
+        style: { backgroundColor: this.backgroundColor || '' },
+        'class': {
+          'el-menu--horizontal': this.mode === 'horizontal',
+          'el-menu--collapse': this.collapse,
+          "el-menu": true
+        }
+      },
+      [this.$slots.default]
+    );
+
+    if (this.collapseTransition) {
+      return h('el-menu-collapse-transition', [component]);
+    } else {
+      return component;
+    }
+  },
+
+
+  componentName: 'ElMenu',
+
+  mixins: [emitter_default.a, migrating_default.a],
+
+  provide: function provide() {
+    return {
+      rootMenu: this
+    };
+  },
+
+
+  components: {
+    'el-menu-collapse-transition': {
+      functional: true,
+      render: function render(createElement, context) {
+        var data = {
+          props: {
+            mode: 'out-in'
+          },
+          on: {
+            beforeEnter: function beforeEnter(el) {
+              el.style.opacity = 0.2;
+            },
+            enter: function enter(el) {
+              Object(dom_["addClass"])(el, 'el-opacity-transition');
+              el.style.opacity = 1;
+            },
+            afterEnter: function afterEnter(el) {
+              Object(dom_["removeClass"])(el, 'el-opacity-transition');
+              el.style.opacity = '';
+            },
+            beforeLeave: function beforeLeave(el) {
+              if (!el.dataset) el.dataset = {};
+
+              if (Object(dom_["hasClass"])(el, 'el-menu--collapse')) {
+                Object(dom_["removeClass"])(el, 'el-menu--collapse');
+                el.dataset.oldOverflow = el.style.overflow;
+                el.dataset.scrollWidth = el.clientWidth;
+                Object(dom_["addClass"])(el, 'el-menu--collapse');
+              } else {
+                Object(dom_["addClass"])(el, 'el-menu--collapse');
+                el.dataset.oldOverflow = el.style.overflow;
+                el.dataset.scrollWidth = el.clientWidth;
+                Object(dom_["removeClass"])(el, 'el-menu--collapse');
+              }
+
+              el.style.width = el.scrollWidth + 'px';
+              el.style.overflow = 'hidden';
+            },
+            leave: function leave(el) {
+              Object(dom_["addClass"])(el, 'horizontal-collapse-transition');
+              el.style.width = el.dataset.scrollWidth + 'px';
+            }
+          }
+        };
+        return createElement('transition', data, context.children);
+      }
+    }
+  },
+
+  props: {
+    mode: {
+      type: String,
+      default: 'vertical'
+    },
+    defaultActive: {
+      type: String,
+      default: ''
+    },
+    defaultOpeneds: Array,
+    uniqueOpened: Boolean,
+    router: Boolean,
+    menuTrigger: {
+      type: String,
+      default: 'hover'
+    },
+    collapse: Boolean,
+    backgroundColor: String,
+    textColor: String,
+    activeTextColor: String,
+    collapseTransition: {
+      type: Boolean,
+      default: true
+    }
+  },
+  data: function data() {
+    return {
+      activeIndex: this.defaultActive,
+      openedMenus: this.defaultOpeneds && !this.collapse ? this.defaultOpeneds.slice(0) : [],
+      items: {},
+      submenus: {}
+    };
+  },
+
+  computed: {
+    hoverBackground: function hoverBackground() {
+      return this.backgroundColor ? this.mixColor(this.backgroundColor, 0.2) : '';
+    },
+    isMenuPopup: function isMenuPopup() {
+      return this.mode === 'horizontal' || this.mode === 'vertical' && this.collapse;
+    }
+  },
+  watch: {
+    defaultActive: function defaultActive(value) {
+      if (!this.items[value]) {
+        this.activeIndex = null;
+      }
+      this.updateActiveIndex(value);
+    },
+    defaultOpeneds: function defaultOpeneds(value) {
+      if (!this.collapse) {
+        this.openedMenus = value;
+      }
+    },
+    collapse: function collapse(value) {
+      if (value) this.openedMenus = [];
+      this.broadcast('ElSubmenu', 'toggle-collapse', value);
+    }
+  },
+  methods: {
+    updateActiveIndex: function updateActiveIndex(val) {
+      var item = this.items[val] || this.items[this.activeIndex] || this.items[this.defaultActive];
+      if (item) {
+        this.activeIndex = item.index;
+        this.initOpenedMenu();
+      } else {
+        this.activeIndex = null;
+      }
+    },
+    getMigratingConfig: function getMigratingConfig() {
+      return {
+        props: {
+          'theme': 'theme is removed.'
+        }
+      };
+    },
+    getColorChannels: function getColorChannels(color) {
+      color = color.replace('#', '');
+      if (/^[0-9a-fA-F]{3}$/.test(color)) {
+        color = color.split('');
+        for (var i = 2; i >= 0; i--) {
+          color.splice(i, 0, color[i]);
+        }
+        color = color.join('');
+      }
+      if (/^[0-9a-fA-F]{6}$/.test(color)) {
+        return {
+          red: parseInt(color.slice(0, 2), 16),
+          green: parseInt(color.slice(2, 4), 16),
+          blue: parseInt(color.slice(4, 6), 16)
+        };
+      } else {
+        return {
+          red: 255,
+          green: 255,
+          blue: 255
+        };
+      }
+    },
+    mixColor: function mixColor(color, percent) {
+      var _getColorChannels = this.getColorChannels(color),
+          red = _getColorChannels.red,
+          green = _getColorChannels.green,
+          blue = _getColorChannels.blue;
+
+      if (percent > 0) {
+        // shade given color
+        red *= 1 - percent;
+        green *= 1 - percent;
+        blue *= 1 - percent;
+      } else {
+        // tint given color
+        red += (255 - red) * percent;
+        green += (255 - green) * percent;
+        blue += (255 - blue) * percent;
+      }
+      return 'rgb(' + Math.round(red) + ', ' + Math.round(green) + ', ' + Math.round(blue) + ')';
+    },
+    addItem: function addItem(item) {
+      this.$set(this.items, item.index, item);
+    },
+    removeItem: function removeItem(item) {
+      delete this.items[item.index];
+    },
+    addSubmenu: function addSubmenu(item) {
+      this.$set(this.submenus, item.index, item);
+    },
+    removeSubmenu: function removeSubmenu(item) {
+      delete this.submenus[item.index];
+    },
+    openMenu: function openMenu(index, indexPath) {
+      var openedMenus = this.openedMenus;
+      if (openedMenus.indexOf(index) !== -1) return;
+      // 将不在该菜单路径下的其余菜单收起
+      // collapse all menu that are not under current menu item
+      if (this.uniqueOpened) {
+        this.openedMenus = openedMenus.filter(function (index) {
+          return indexPath.indexOf(index) !== -1;
+        });
+      }
+      this.openedMenus.push(index);
+    },
+    closeMenu: function closeMenu(index) {
+      var i = this.openedMenus.indexOf(index);
+      if (i !== -1) {
+        this.openedMenus.splice(i, 1);
+      }
+    },
+    handleSubmenuClick: function handleSubmenuClick(submenu) {
+      var index = submenu.index,
+          indexPath = submenu.indexPath;
+
+      var isOpened = this.openedMenus.indexOf(index) !== -1;
+
+      if (isOpened) {
+        this.closeMenu(index);
+        this.$emit('close', index, indexPath);
+      } else {
+        this.openMenu(index, indexPath);
+        this.$emit('open', index, indexPath);
+      }
+    },
+    handleItemClick: function handleItemClick(item) {
+      var _this = this;
+
+      var index = item.index,
+          indexPath = item.indexPath;
+
+      var oldActiveIndex = this.activeIndex;
+      var hasIndex = item.index !== null;
+
+      if (hasIndex) {
+        this.activeIndex = item.index;
+      }
+
+      this.$emit('select', index, indexPath, item);
+
+      if (this.mode === 'horizontal' || this.collapse) {
+        this.openedMenus = [];
+      }
+
+      if (this.router && hasIndex) {
+        this.routeToItem(item, function (error) {
+          _this.activeIndex = oldActiveIndex;
+          if (error) {
+            // vue-router 3.1.0+ push/replace cause NavigationDuplicated error 
+            // https://github.com/ElemeFE/element/issues/17044
+            if (error.name === 'NavigationDuplicated') return;
+            console.error(error);
+          }
+        });
+      }
+    },
+
+    // 初始化展开菜单
+    // initialize opened menu
+    initOpenedMenu: function initOpenedMenu() {
+      var _this2 = this;
+
+      var index = this.activeIndex;
+      var activeItem = this.items[index];
+      if (!activeItem || this.mode === 'horizontal' || this.collapse) return;
+
+      var indexPath = activeItem.indexPath;
+
+      // 展开该菜单项的路径上所有子菜单
+      // expand all submenus of the menu item
+      indexPath.forEach(function (index) {
+        var submenu = _this2.submenus[index];
+        submenu && _this2.openMenu(index, submenu.indexPath);
+      });
+    },
+    routeToItem: function routeToItem(item, onError) {
+      var route = item.route || item.index;
+      try {
+        this.$router.push(route, function () {}, onError);
+      } catch (e) {
+        console.error(e);
+      }
+    },
+    open: function open(index) {
+      var _this3 = this;
+
+      var indexPath = this.submenus[index.toString()].indexPath;
+
+      indexPath.forEach(function (i) {
+        return _this3.openMenu(i, indexPath);
+      });
+    },
+    close: function close(index) {
+      this.closeMenu(index);
+    }
+  },
+  mounted: function mounted() {
+    this.initOpenedMenu();
+    this.$on('item-click', this.handleItemClick);
+    this.$on('submenu-click', this.handleSubmenuClick);
+    if (this.mode === 'horizontal') {
+      new aria_menubar(this.$el); // eslint-disable-line
+    }
+    this.$watch('items', this.updateActiveIndex);
+  }
+});
+// CONCATENATED MODULE: ./packages/menu/src/menu.vue?vue&type=script&lang=js&
+ /* harmony default export */ var src_menuvue_type_script_lang_js_ = (menuvue_type_script_lang_js_); 
+// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
+var componentNormalizer = __webpack_require__(0);
+
+// CONCATENATED MODULE: ./packages/menu/src/menu.vue
+var menu_render, staticRenderFns
+
+
+
+
+/* normalize component */
+
+var component = Object(componentNormalizer["a" /* default */])(
+  src_menuvue_type_script_lang_js_,
+  menu_render,
+  staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* hot reload */
+if (false) { var api; }
+component.options.__file = "packages/menu/src/menu.vue"
+/* harmony default export */ var menu = (component.exports);
+// CONCATENATED MODULE: ./packages/menu/index.js
+
+
+/* istanbul ignore next */
+menu.install = function (Vue) {
+  Vue.component(menu.name, menu);
+};
+
+/* harmony default export */ var packages_menu = __webpack_exports__["default"] = (menu);
+
+/***/ })
+
+/******/ });