ele-admin-plus 1.2.1-beta.3 → 1.2.1-beta.4

package/es/ele-menus/components/item-title.d.ts

@@ -0,0 +1,48 @@
+import { PropType } from 'vue';
+import { isExternalLink } from '../../utils/core';
+import { MenuItem, MenuItemEvent } from '../types';
+
+declare const _default: import('vue').DefineComponent<{
+    /** 菜单项数据 */
+    item: {
+        type: PropType<MenuItem>;
+        required: true;
+    };
+    /** 是否需要标题 */
+    showTitle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 是否需要链接 */
+    showLink: BooleanConstructor;
+}, {
+    isExternalLink: typeof isExternalLink;
+    handleItemClick: MenuItemEvent;
+    handleItemMouseenter: MenuItemEvent;
+    handleItemMouseleave: MenuItemEvent;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    itemClick: (_item: MenuItem, _e: MouseEvent) => true;
+    itemMouseenter: (_item: MenuItem, _e: MouseEvent) => true;
+    itemMouseleave: (_item: MenuItem, _e: MouseEvent) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 菜单项数据 */
+    item: {
+        type: PropType<MenuItem>;
+        required: true;
+    };
+    /** 是否需要标题 */
+    showTitle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 是否需要链接 */
+    showLink: BooleanConstructor;
+}>> & {
+    onItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+}, {
+    showTitle: boolean;
+    showLink: boolean;
+}, {}>;
+export default _default;

package/es/ele-menus/components/item-title.js

@@ -0,0 +1,108 @@
+import { defineComponent, resolveComponent, openBlock, createElementBlock, Fragment, renderSlot, createBlock, normalizeProps, mergeProps, withCtx, resolveDynamicComponent, normalizeStyle, createCommentVNode, toDisplayString, createElementVNode, withModifiers } from "vue";
+import { ElIcon, ElBadge } from "element-plus";
+import { isExternalLink } from "../../utils/core";
+const _sfc_main = defineComponent({
+  name: "ItemTitle",
+  components: { ElIcon, ElBadge },
+  props: {
+    /** 菜单项数据 */
+    item: {
+      type: Object,
+      required: true
+    },
+    /** 是否需要标题 */
+    showTitle: {
+      type: Boolean,
+      default: true
+    },
+    /** 是否需要链接 */
+    showLink: Boolean
+  },
+  emits: {
+    itemClick: (_item, _e) => true,
+    itemMouseenter: (_item, _e) => true,
+    itemMouseleave: (_item, _e) => true
+  },
+  setup(_props, { emit }) {
+    const handleItemClick = (item, e) => {
+      emit("itemClick", item, e);
+    };
+    const handleItemMouseenter = (item, e) => {
+      emit("itemMouseenter", item, e);
+    };
+    const handleItemMouseleave = (item, e) => {
+      emit("itemMouseleave", item, e);
+    };
+    return {
+      isExternalLink,
+      handleItemClick,
+      handleItemMouseenter,
+      handleItemMouseleave
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = {
+  key: 0,
+  class: "ele-menu-title"
+};
+const _hoisted_2 = ["href"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_ElBadge = resolveComponent("ElBadge");
+  const _component_RouterLink = resolveComponent("RouterLink");
+  return openBlock(), createElementBlock(Fragment, null, [
+    renderSlot(_ctx.$slots, "icon", {
+      item: _ctx.item,
+      icon: _ctx.item.icon
+    }, () => [
+      _ctx.item.icon ? (openBlock(), createBlock(_component_ElIcon, normalizeProps(mergeProps({ key: 0 }, _ctx.item.iconProps || {})), {
+        default: withCtx(() => [
+          (openBlock(), createBlock(resolveDynamicComponent(_ctx.item.icon), {
+            style: normalizeStyle(_ctx.item.iconStyle)
+          }, null, 8, ["style"]))
+        ]),
+        _: 1
+      }, 16)) : createCommentVNode("", true)
+    ]),
+    _ctx.showTitle ? renderSlot(_ctx.$slots, "title", {
+      key: 0,
+      item: _ctx.item,
+      title: _ctx.item.title
+    }, () => [
+      _ctx.item.title ? (openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(_ctx.item.title), 1)) : createCommentVNode("", true)
+    ]) : createCommentVNode("", true),
+    _ctx.item.badge != null ? (openBlock(), createBlock(_component_ElBadge, normalizeProps(mergeProps({ key: 1 }, _ctx.item.badge)), null, 16)) : createCommentVNode("", true),
+    createElementVNode("div", {
+      class: "ele-menu-trigger",
+      onClick: _cache[1] || (_cache[1] = (e) => _ctx.handleItemClick(_ctx.item, e)),
+      onMouseenter: _cache[2] || (_cache[2] = (e) => _ctx.handleItemMouseenter(_ctx.item, e)),
+      onMouseleave: _cache[3] || (_cache[3] = (e) => _ctx.handleItemMouseleave(_ctx.item, e))
+    }, [
+      _ctx.showLink ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+        _ctx.isExternalLink(_ctx.item.path) ? (openBlock(), createElementBlock("a", {
+          key: 0,
+          href: _ctx.item.path,
+          target: "_blank",
+          class: "ele-menu-link",
+          onClick: _cache[0] || (_cache[0] = withModifiers(() => {
+          }, ["stop"]))
+        }, null, 8, _hoisted_2)) : _ctx.item.path ? (openBlock(), createBlock(_component_RouterLink, {
+          key: 1,
+          to: _ctx.item.path,
+          class: "ele-menu-link"
+        }, null, 8, ["to"])) : createCommentVNode("", true)
+      ], 64)) : createCommentVNode("", true)
+    ], 32)
+  ], 64);
+}
+const itemTitle = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  itemTitle as default
+};

package/es/ele-menus/components/menu-items.d.ts

@@ -0,0 +1,78 @@
+import { PropType } from 'vue';
+import { pick } from '../../utils/core';
+import { getPopperClass } from '../util';
+import { MenuItem, MenuTheme, PopupMenuTheme, PopupColorful, MenuItemEvent } from '../types';
+
+declare const _default: import('vue').DefineComponent<{
+    /** 菜单数据 */
+    items: PropType<MenuItem[]>;
+    /** 是否是第一级菜单 */
+    first: BooleanConstructor;
+    /** 是否禁用折叠的 tooltip */
+    tipDisabled: BooleanConstructor;
+    /** 父级是否是分组菜单 */
+    parentIsGroup: BooleanConstructor;
+    /** 主题 */
+    theme: PropType<MenuTheme>;
+    /** 气泡菜单主题 */
+    popTheme: PropType<PopupMenuTheme>;
+    /** 是否彩色图标 */
+    colorful: BooleanConstructor;
+    /** 气泡菜单是否彩色图标 */
+    popupColorful: PropType<PopupColorful>;
+    /** 第一级气泡菜单类名 */
+    firstPopClass: StringConstructor;
+    /** 是否是 webkit 内核 */
+    webkit: BooleanConstructor;
+}, {
+    pick: typeof pick;
+    ArrowDown: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;
+    ArrowRight: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;
+    getPopperClass: typeof getPopperClass;
+    handleMenuItemClick: () => void;
+    handleItemClick: MenuItemEvent;
+    handleItemMouseenter: MenuItemEvent;
+    handleItemMouseleave: MenuItemEvent;
+    handleParentMouseenter: MenuItemEvent;
+    handleParentMouseleave: MenuItemEvent;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    itemClick: (_item: MenuItem, _e: MouseEvent) => true;
+    itemMouseenter: (_item: MenuItem, _e: MouseEvent) => true;
+    itemMouseleave: (_item: MenuItem, _e: MouseEvent) => true;
+    parentMouseenter: (_item: MenuItem, _e: MouseEvent) => true;
+    parentMouseleave: (_item: MenuItem, _e: MouseEvent) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 菜单数据 */
+    items: PropType<MenuItem[]>;
+    /** 是否是第一级菜单 */
+    first: BooleanConstructor;
+    /** 是否禁用折叠的 tooltip */
+    tipDisabled: BooleanConstructor;
+    /** 父级是否是分组菜单 */
+    parentIsGroup: BooleanConstructor;
+    /** 主题 */
+    theme: PropType<MenuTheme>;
+    /** 气泡菜单主题 */
+    popTheme: PropType<PopupMenuTheme>;
+    /** 是否彩色图标 */
+    colorful: BooleanConstructor;
+    /** 气泡菜单是否彩色图标 */
+    popupColorful: PropType<PopupColorful>;
+    /** 第一级气泡菜单类名 */
+    firstPopClass: StringConstructor;
+    /** 是否是 webkit 内核 */
+    webkit: BooleanConstructor;
+}>> & {
+    onItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onParentMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onParentMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+}, {
+    first: boolean;
+    colorful: boolean;
+    tipDisabled: boolean;
+    parentIsGroup: boolean;
+    webkit: boolean;
+}, {}>;
+export default _default;

package/es/ele-menus/components/menu-items.js

@@ -0,0 +1,269 @@
+import { defineComponent, resolveComponent, openBlock, createElementBlock, Fragment, renderList, createBlock, mergeProps, createSlots, withCtx, createVNode, renderSlot, toDisplayString, createCommentVNode, normalizeClass, normalizeStyle } from "vue";
+import { ElMenuItem, ElSubMenu, ElMenuItemGroup } from "element-plus";
+import { ArrowDown, ArrowRight } from "../../icons";
+import { pick } from "../../utils/core";
+import ItemTitle from "./item-title";
+import { getPopperClass } from "../util";
+const _sfc_main = defineComponent({
+  name: "MenuItems",
+  components: { ElMenuItem, ElSubMenu, ElMenuItemGroup, ItemTitle },
+  props: {
+    /** 菜单数据 */
+    items: Array,
+    /** 是否是第一级菜单 */
+    first: Boolean,
+    /** 是否禁用折叠的 tooltip */
+    tipDisabled: Boolean,
+    /** 父级是否是分组菜单 */
+    parentIsGroup: Boolean,
+    /** 主题 */
+    theme: String,
+    /** 气泡菜单主题 */
+    popTheme: String,
+    /** 是否彩色图标 */
+    colorful: Boolean,
+    /** 气泡菜单是否彩色图标 */
+    popupColorful: [Boolean, String],
+    /** 第一级气泡菜单类名 */
+    firstPopClass: String,
+    /** 是否是 webkit 内核 */
+    webkit: Boolean
+  },
+  emits: {
+    itemClick: (_item, _e) => true,
+    itemMouseenter: (_item, _e) => true,
+    itemMouseleave: (_item, _e) => true,
+    parentMouseenter: (_item, _e) => true,
+    parentMouseleave: (_item, _e) => true
+  },
+  setup(_props, { emit }) {
+    const handleMenuItemClick = () => {
+    };
+    const handleItemClick = (item, e) => {
+      emit("itemClick", item, e);
+    };
+    const handleItemMouseenter = (item, e) => {
+      emit("itemMouseenter", item, e);
+    };
+    const handleItemMouseleave = (item, e) => {
+      emit("itemMouseleave", item, e);
+    };
+    const handleParentMouseenter = (item, e) => {
+      emit("parentMouseenter", item, e);
+    };
+    const handleParentMouseleave = (item, e) => {
+      emit("parentMouseleave", item, e);
+    };
+    return {
+      pick,
+      ArrowDown,
+      ArrowRight,
+      getPopperClass,
+      handleMenuItemClick,
+      handleItemClick,
+      handleItemMouseenter,
+      handleItemMouseleave,
+      handleParentMouseenter,
+      handleParentMouseleave
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = {
+  key: 0,
+  class: "ele-menu-title"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ItemTitle = resolveComponent("ItemTitle");
+  const _component_ElMenuItem = resolveComponent("ElMenuItem");
+  const _component_MenuItems = resolveComponent("MenuItems", true);
+  const _component_ElMenuItemGroup = resolveComponent("ElMenuItemGroup");
+  const _component_ElSubMenu = resolveComponent("ElSubMenu");
+  return openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.items, (item) => {
+    return openBlock(), createElementBlock(Fragment, null, [
+      !item.children || !item.children.length ? (openBlock(), createBlock(_component_ElMenuItem, mergeProps({
+        key: 0,
+        ref_for: true
+      }, _ctx.pick(item, ["route", "disabled", "class", "style"]), {
+        key: (item.key || item.index || item.path) + "-" + _ctx.tipDisabled,
+        index: item.index || item.path,
+        class: [{ "ele-menu-overflow": item.overflow }],
+        onClick: _ctx.handleMenuItemClick
+      }), createSlots({
+        default: withCtx(() => [
+          createVNode(_component_ItemTitle, {
+            item,
+            showTitle: !(_ctx.first && !_ctx.tipDisabled),
+            showLink: true,
+            onItemClick: _ctx.handleItemClick,
+            onItemMouseenter: _ctx.handleItemMouseenter,
+            onItemMouseleave: _ctx.handleItemMouseleave
+          }, createSlots({ _: 2 }, [
+            renderList(Object.keys(_ctx.$slots), (name) => {
+              return {
+                name,
+                fn: withCtx((slotProps) => [
+                  renderSlot(_ctx.$slots, name, mergeProps({ ref_for: true }, slotProps || {}))
+                ])
+              };
+            })
+          ]), 1032, ["item", "showTitle", "onItemClick", "onItemMouseenter", "onItemMouseleave"])
+        ]),
+        _: 2
+      }, [
+        _ctx.first && !_ctx.tipDisabled ? {
+          name: "title",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "title", {
+              item,
+              title: item.title
+            }, () => [
+              item.title ? (openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(item.title), 1)) : createCommentVNode("", true)
+            ])
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1040, ["index", "class", "onClick"])) : item.group === true && !_ctx.parentIsGroup ? (openBlock(), createBlock(_component_ElMenuItemGroup, {
+        key: (item.key || item.index || item.path) + "-group",
+        class: normalizeClass(item.class),
+        style: normalizeStyle(item.style)
+      }, {
+        title: withCtx(() => [
+          createVNode(_component_ItemTitle, {
+            item,
+            onItemMouseenter: _ctx.handleParentMouseenter,
+            onItemMouseleave: _ctx.handleParentMouseleave
+          }, createSlots({ _: 2 }, [
+            renderList(Object.keys(_ctx.$slots), (name) => {
+              return {
+                name,
+                fn: withCtx((slotProps) => [
+                  renderSlot(_ctx.$slots, name, mergeProps({ ref_for: true }, slotProps || {}))
+                ])
+              };
+            })
+          ]), 1032, ["item", "onItemMouseenter", "onItemMouseleave"])
+        ]),
+        default: withCtx(() => [
+          createVNode(_component_MenuItems, {
+            items: item.children,
+            first: _ctx.first,
+            tipDisabled: _ctx.tipDisabled,
+            parentIsGroup: true,
+            theme: _ctx.theme,
+            popTheme: _ctx.popTheme,
+            colorful: _ctx.colorful,
+            popupColorful: _ctx.popupColorful,
+            firstPopClass: _ctx.firstPopClass,
+            webkit: _ctx.webkit,
+            onItemClick: _ctx.handleItemClick,
+            onItemMouseenter: _ctx.handleItemMouseenter,
+            onItemMouseleave: _ctx.handleItemMouseleave,
+            onParentMouseenter: _ctx.handleParentMouseenter,
+            onParentMouseleave: _ctx.handleParentMouseleave
+          }, createSlots({ _: 2 }, [
+            renderList(Object.keys(_ctx.$slots), (name) => {
+              return {
+                name,
+                fn: withCtx((slotProps) => [
+                  renderSlot(_ctx.$slots, name, mergeProps({ ref_for: true }, slotProps || {}))
+                ])
+              };
+            })
+          ]), 1032, ["items", "first", "tipDisabled", "theme", "popTheme", "colorful", "popupColorful", "firstPopClass", "webkit", "onItemClick", "onItemMouseenter", "onItemMouseleave", "onParentMouseenter", "onParentMouseleave"])
+        ]),
+        _: 2
+      }, 1032, ["class", "style"])) : (openBlock(), createBlock(_component_ElSubMenu, mergeProps(
+        {
+          key: 2,
+          ref_for: true
+        },
+        _ctx.pick(item, [
+          "showTimeout",
+          "hideTimeout",
+          "disabled",
+          "popperOffset",
+          "class",
+          "style"
+        ]),
+        {
+          key: (item.key || item.index || item.path) + "-sub",
+          index: item.index || item.path || "",
+          popperClass: _ctx.getPopperClass(
+            item.popperClass,
+            _ctx.theme,
+            _ctx.popTheme,
+            _ctx.colorful,
+            _ctx.popupColorful,
+            _ctx.firstPopClass,
+            _ctx.first,
+            _ctx.webkit
+          ),
+          teleported: item.teleported ?? !!_ctx.first,
+          expandCloseIcon: item.expandCloseIcon ?? _ctx.ArrowDown,
+          expandOpenIcon: item.expandOpenIcon ?? _ctx.ArrowDown,
+          collapseCloseIcon: item.collapseCloseIcon ?? _ctx.ArrowRight,
+          collapseOpenIcon: item.collapseOpenIcon ?? _ctx.ArrowRight,
+          class: [{ "ele-menu-overflow": item.overflow }]
+        }
+      ), {
+        title: withCtx(() => [
+          createVNode(_component_ItemTitle, {
+            item,
+            onItemMouseenter: _ctx.handleParentMouseenter,
+            onItemMouseleave: _ctx.handleParentMouseleave
+          }, createSlots({ _: 2 }, [
+            renderList(Object.keys(_ctx.$slots), (name) => {
+              return {
+                name,
+                fn: withCtx((slotProps) => [
+                  renderSlot(_ctx.$slots, name, mergeProps({ ref_for: true }, slotProps || {}))
+                ])
+              };
+            })
+          ]), 1032, ["item", "onItemMouseenter", "onItemMouseleave"])
+        ]),
+        default: withCtx(() => [
+          !(item.children.length === 1 && item.children[0] == null) ? (openBlock(), createBlock(_component_MenuItems, {
+            key: 0,
+            items: item.children,
+            first: false,
+            tipDisabled: _ctx.tipDisabled,
+            parentIsGroup: false,
+            theme: _ctx.theme,
+            popTheme: _ctx.popTheme,
+            colorful: _ctx.colorful,
+            popupColorful: _ctx.popupColorful,
+            firstPopClass: _ctx.firstPopClass,
+            webkit: _ctx.webkit,
+            onItemClick: _ctx.handleItemClick,
+            onItemMouseenter: _ctx.handleItemMouseenter,
+            onItemMouseleave: _ctx.handleItemMouseleave,
+            onParentMouseenter: _ctx.handleParentMouseenter,
+            onParentMouseleave: _ctx.handleParentMouseleave
+          }, createSlots({ _: 2 }, [
+            renderList(Object.keys(_ctx.$slots), (name) => {
+              return {
+                name,
+                fn: withCtx((slotProps) => [
+                  renderSlot(_ctx.$slots, name, mergeProps({ ref_for: true }, slotProps || {}))
+                ])
+              };
+            })
+          ]), 1032, ["items", "tipDisabled", "theme", "popTheme", "colorful", "popupColorful", "firstPopClass", "webkit", "onItemClick", "onItemMouseenter", "onItemMouseleave", "onParentMouseenter", "onParentMouseleave"])) : createCommentVNode("", true)
+        ]),
+        _: 2
+      }, 1040, ["index", "popperClass", "teleported", "expandCloseIcon", "expandOpenIcon", "collapseCloseIcon", "collapseOpenIcon", "class"]))
+    ], 64);
+  }), 256);
+}
+const menuItems = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  menuItems as default
+};

package/es/ele-menus/index.d.ts

@@ -1,11 +1,13 @@
 import { NavigationFailure } from 'vue-router';
 import { MenuItemClicked } from 'element-plus';
-import { ElMenuInstance } from '../ele-app/el';
+import { ElMenuInstance, ElSubMenuInstance } from '../ele-app/el';
+import { getPopperClass } from './util';
+import { MenuItem, MenuItemEvent } from './types';
 
 declare const _default: import('vue').DefineComponent<{
     mode: import('vue').PropType<import('./types').MenuMode>;
     items: {
-        type: import('vue').PropType<import('./types').MenuItem[]>;
+        type: import('vue').PropType<MenuItem[]>;
         required: boolean;
     };
     theme: import('vue').PropType<import('./types').MenuTheme>;
@@ -36,28 +38,85 @@ declare const _default: import('vue').DefineComponent<{
     ellipsis: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
     popperOffset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
     ellipsisIcon: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown, () => any, boolean>;
-    popperEffect: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "light" | "dark", unknown, "dark", boolean>;
+    popperEffect: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "dark", boolean>;
     popperClass: StringConstructor;
     showTimeout: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
     hideTimeout: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
 }, {
+    EllipsisOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;
+    getPopperClass: typeof getPopperClass;
+    isWebkit: boolean;
     menuRef: import('vue').Ref<ElMenuInstance>;
-    scrollToActive: () => void;
+    ellipsisRef: import('vue').Ref<ElSubMenuInstance>;
+    menuItems: import('vue').ShallowRef<MenuItem[] | undefined>;
+    moreMenuItems: import('vue').ShallowRef<MenuItem[] | undefined>;
+    tooltipVirtualRef: import('vue').Ref<any>;
+    tooltipContent: import('vue').Ref<string>;
+    tooltipVisible: import('vue').Ref<boolean>;
+    isCompact: import('vue').ComputedRef<boolean>;
+    collapseTooltipDisabled: import('vue').ComputedRef<boolean>;
+    menuProps: import('vue').ComputedRef<import('../ele-app/types').Mutable<Pick<import('@vue/shared').LooseRequired<{
+        readonly showTimeout: number;
+        readonly hideTimeout: number;
+        readonly defaultActive: string;
+        readonly defaultOpeneds: string[];
+        readonly uniqueOpened: boolean;
+        readonly router: boolean;
+        readonly menuTrigger: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "hover" | "click", unknown>;
+        readonly collapse: boolean;
+        readonly closeOnClickOutside: boolean;
+        readonly collapseTransition: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly ellipsis: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly popperOffset: number;
+        readonly popperEffect: string;
+        readonly popupTheme: import('./types').PopupMenuTheme;
+        readonly colorful: boolean;
+        readonly popupColorful: import('./types').PopupColorful;
+        readonly tooltipDisabled: boolean;
+        readonly popperClass?: string | undefined;
+        readonly mode?: import('./types').MenuMode | undefined;
+        readonly backgroundColor?: string | undefined;
+        readonly textColor?: string | undefined;
+        readonly activeTextColor?: string | undefined;
+        readonly ellipsisIcon?: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown> | undefined;
+        readonly items?: MenuItem[] | undefined;
+        readonly theme?: import('./types').MenuTheme | undefined;
+        readonly firstPopperClass?: string | undefined;
+        readonly ellipsisProps?: import('./types').EllipsisProps | undefined;
+        readonly textEllipsisTooltip?: import('./types').TextEllipsisTooltip | undefined;
+        readonly onSelect?: ((index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure> | undefined) => any) | undefined;
+        readonly onClose?: ((index: string, indexPath: string[]) => any) | undefined;
+        readonly onOpen?: ((index: string, indexPath: string[]) => any) | undefined;
+        readonly onItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+        readonly onItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+        readonly onItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+        readonly onParentMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+        readonly onParentMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    } & {}>, "popperClass" | "showTimeout" | "hideTimeout" | "mode" | "defaultActive" | "defaultOpeneds" | "uniqueOpened" | "router" | "menuTrigger" | "collapse" | "backgroundColor" | "textColor" | "activeTextColor" | "closeOnClickOutside" | "collapseTransition" | "ellipsis" | "popperOffset" | "ellipsisIcon" | "popperEffect">>>;
     open: (index: string) => void;
     close: (index: string) => void;
+    handleOpen: (index: string, indexPath: string[]) => void;
+    handleClose: (index: string, indexPath: string[]) => void;
+    handleSelect: (index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure> | undefined) => void;
+    handleItemClick: MenuItemEvent;
+    handleItemMouseenter: MenuItemEvent;
+    handleItemMouseleave: MenuItemEvent;
+    handleParentMouseenter: MenuItemEvent;
+    handleParentMouseleave: MenuItemEvent;
+    scrollToActive: () => void;
 }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    itemClick: (_item: import('./types').MenuItem, _e: MouseEvent) => boolean;
-    itemMouseenter: (_item: import('./types').MenuItem, _e: MouseEvent) => boolean;
-    itemMouseleave: (_item: import('./types').MenuItem, _e: MouseEvent) => boolean;
-    parentMouseenter: (_item: import('./types').MenuItem, _e: MouseEvent) => boolean;
-    parentMouseleave: (_item: import('./types').MenuItem, _e: MouseEvent) => boolean;
+    itemClick: (_item: MenuItem, _e: MouseEvent) => boolean;
+    itemMouseenter: (_item: MenuItem, _e: MouseEvent) => boolean;
+    itemMouseleave: (_item: MenuItem, _e: MouseEvent) => boolean;
+    parentMouseenter: (_item: MenuItem, _e: MouseEvent) => boolean;
+    parentMouseleave: (_item: MenuItem, _e: MouseEvent) => boolean;
     close: (index: string, indexPath: string[]) => boolean;
     open: (index: string, indexPath: string[]) => boolean;
-    select: (index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure> | undefined) => boolean;
+    select: (index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure>) => boolean;
 }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     mode: import('vue').PropType<import('./types').MenuMode>;
     items: {
-        type: import('vue').PropType<import('./types').MenuItem[]>;
+        type: import('vue').PropType<MenuItem[]>;
         required: boolean;
     };
     theme: import('vue').PropType<import('./types').MenuTheme>;
@@ -88,7 +147,7 @@ declare const _default: import('vue').DefineComponent<{
     ellipsis: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
     popperOffset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
     ellipsisIcon: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown, () => any, boolean>;
-    popperEffect: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "light" | "dark", unknown, "dark", boolean>;
+    popperEffect: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "dark", boolean>;
     popperClass: StringConstructor;
     showTimeout: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
     hideTimeout: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
@@ -96,11 +155,11 @@ declare const _default: import('vue').DefineComponent<{
     onSelect?: ((index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure> | undefined) => any) | undefined;
     onClose?: ((index: string, indexPath: string[]) => any) | undefined;
     onOpen?: ((index: string, indexPath: string[]) => any) | undefined;
-    onItemClick?: ((_item: import('./types').MenuItem, _e: MouseEvent) => any) | undefined;
-    onItemMouseenter?: ((_item: import('./types').MenuItem, _e: MouseEvent) => any) | undefined;
-    onItemMouseleave?: ((_item: import('./types').MenuItem, _e: MouseEvent) => any) | undefined;
-    onParentMouseenter?: ((_item: import('./types').MenuItem, _e: MouseEvent) => any) | undefined;
-    onParentMouseleave?: ((_item: import('./types').MenuItem, _e: MouseEvent) => any) | undefined;
+    onItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onParentMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onParentMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
 }, {
     showTimeout: number;
     hideTimeout: number;
@@ -115,7 +174,7 @@ declare const _default: import('vue').DefineComponent<{
     ellipsis: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
     popperOffset: number;
     ellipsisIcon: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>;
-    popperEffect: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "light" | "dark", unknown>;
+    popperEffect: string;
     popupTheme: import('./types').PopupMenuTheme;
     colorful: boolean;
     popupColorful: import('./types').PopupColorful;