@vunk/plus 0.0.4 → 0.2.0

package/components/routes-menu-content/index.d.ts

@@ -0,0 +1,4 @@
+import VkRoutesMenuContent from './src/index.vue';
+export * as __VkRoutesMenuContent from './src/types';
+export { VkRoutesMenuContent, };
+export default VkRoutesMenuContent;

package/components/routes-menu-content/index.mjs

@@ -0,0 +1,305 @@
+import { defineComponent, computed, resolveComponent, openBlock, createBlock, withCtx, renderSlot, createElementBlock, Fragment, mergeProps, normalizeProps, guardReactiveProps, createCommentVNode, renderList, createVNode } from 'vue';
+import { resolveFullPath } from '@vunk/shared/string/url';
+import { ElSubMenu, ElMenuItem } from 'element-plus';
+import { bindPropsFactory } from '@vunk/core/shared/utils-vue';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+
+const props$2 = {
+  data: {
+    type: Array,
+    default: () => []
+  },
+  popperClass: {
+    type: String,
+    default: "vk-routes-menu-content-popper"
+  },
+  basePath: {
+    type: String,
+    default: ""
+  }
+};
+const emits = {};
+
+const props$1 = {
+  data: {
+    type: Object,
+    default: () => ({})
+  },
+  popperClass: {
+    type: String,
+    default: ""
+  },
+  basePath: {
+    type: String,
+    default: ""
+  }
+};
+const createBindProps = bindPropsFactory(props$1);
+
+var _sfc_main$2 = defineComponent({
+  components: {
+    ElSubMenu,
+    ElMenuItem
+  },
+  props: props$1,
+  setup(props2) {
+    const hasChildren = computed(() => {
+      let flag = false;
+      if (props2.data.children) {
+        flag = props2.data.children.some((item) => {
+          return item.meta?.display != 0 && item.meta?.hidden !== true;
+        });
+      }
+      return flag;
+    });
+    const subMenuIndex = computed(() => {
+      const meta = props2.data.meta;
+      return meta?.subMenuIndex ? meta.subMenuIndex : resolveFullPath(props2.data.path, props2.basePath);
+    });
+    return {
+      resolveFullPath,
+      hasChildren,
+      subMenuIndex
+    };
+  }
+});
+
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElSubMenu = resolveComponent("ElSubMenu");
+  const _component_ElMenuItem = resolveComponent("ElMenuItem");
+  return _ctx.hasChildren ? (openBlock(), createBlock(_component_ElSubMenu, {
+    key: 0,
+    index: _ctx.subMenuIndex,
+    "popper-class": _ctx.popperClass
+  }, {
+    title: withCtx(() => [
+      renderSlot(_ctx.$slots, "menuTitle", {
+        data: _ctx.data,
+        href: _ctx.resolveFullPath(_ctx.data.path, _ctx.basePath),
+        basePath: _ctx.basePath
+      })
+    ]),
+    default: withCtx(() => [
+      renderSlot(_ctx.$slots, "default")
+    ]),
+    _: 3
+    /* FORWARDED */
+  }, 8, ["index", "popper-class"])) : (openBlock(), createBlock(_component_ElMenuItem, {
+    key: 1,
+    index: _ctx.resolveFullPath(_ctx.data.path, _ctx.basePath)
+  }, {
+    title: withCtx(() => [
+      renderSlot(_ctx.$slots, "itemTitle", {
+        data: _ctx.data,
+        href: _ctx.resolveFullPath(_ctx.data.path, _ctx.basePath),
+        basePath: _ctx.basePath
+      })
+    ]),
+    default: withCtx(() => [
+      renderSlot(_ctx.$slots, "item", {
+        data: _ctx.data,
+        href: _ctx.resolveFullPath(_ctx.data.path, _ctx.basePath),
+        basePath: _ctx.basePath
+      })
+    ]),
+    _: 3
+    /* FORWARDED */
+  }, 8, ["index"]));
+}
+var CoreVue = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/routes-menu-content/src/item/core/index.vue"]]);
+
+const props = {
+  ...props$1
+};
+
+const skipRender = Symbol("skipRender");
+var _sfc_main$1 = defineComponent({
+  components: {
+    CoreVue
+  },
+  props,
+  setup(props2) {
+    const bindProps = createBindProps(props2);
+    const onlyData = computed(() => {
+      return getOnly(props2.data);
+    });
+    function getOnly(data, merge = {}) {
+      const children = data.children;
+      const paths = merge.paths || [data.path];
+      if (data.meta?.alwaysShow) return;
+      if (children) {
+        const showChildren = children.filter((item) => item.meta?.display != 0 && item.meta?.hidden !== true);
+        if (showChildren.length === 1) {
+          const one = showChildren[0];
+          paths.push(one.path);
+          one[skipRender] = true;
+          if (one.children?.length) {
+            const oneShowChildren = one.children.filter((item) => item.meta?.display != 0 && item.meta?.hidden !== true);
+            if (oneShowChildren.length) {
+              return getOnly(one, { paths });
+            }
+          }
+          return {
+            ...one,
+            meta: {
+              ...data.meta ?? {},
+              ...one.meta ?? {}
+            },
+            _paths: paths,
+            path: paths.reduce((prev, next) => {
+              if (!prev) {
+                return next;
+              }
+              if (next.startsWith("/")) {
+                return next;
+              } else {
+                return prev + "/" + next;
+              }
+            }, "")
+          };
+        }
+      }
+    }
+    return {
+      skipRender,
+      onlyData,
+      bindProps
+    };
+  }
+});
+
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_CoreVue = resolveComponent("CoreVue");
+  return _ctx.data.meta?.display != 0 && _ctx.data.meta?.hidden !== true ? (openBlock(), createElementBlock(
+    Fragment,
+    { key: 0 },
+    [
+      !_ctx.data[_ctx.skipRender] ? (openBlock(), createElementBlock(
+        Fragment,
+        { key: 0 },
+        [
+          _ctx.onlyData ? (openBlock(), createBlock(_component_CoreVue, mergeProps({ key: 0 }, _ctx.bindProps, { data: _ctx.onlyData }), {
+            item: withCtx((e) => [
+              renderSlot(_ctx.$slots, "item", normalizeProps(guardReactiveProps(e)))
+            ]),
+            menuTitle: withCtx((e) => [
+              renderSlot(_ctx.$slots, "menuTitle", normalizeProps(guardReactiveProps(e)))
+            ]),
+            itemTitle: withCtx((e) => [
+              renderSlot(_ctx.$slots, "itemTitle", normalizeProps(guardReactiveProps(e)))
+            ]),
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+            /* FORWARDED */
+          }, 16, ["data"])) : (openBlock(), createBlock(
+            _component_CoreVue,
+            normalizeProps(mergeProps({ key: 1 }, _ctx.bindProps)),
+            {
+              item: withCtx((e) => [
+                renderSlot(_ctx.$slots, "item", normalizeProps(guardReactiveProps(e)))
+              ]),
+              menuTitle: withCtx((e) => [
+                renderSlot(_ctx.$slots, "menuTitle", normalizeProps(guardReactiveProps(e)))
+              ]),
+              itemTitle: withCtx((e) => [
+                renderSlot(_ctx.$slots, "itemTitle", normalizeProps(guardReactiveProps(e)))
+              ]),
+              default: withCtx(() => [
+                renderSlot(_ctx.$slots, "default")
+              ]),
+              _: 3
+              /* FORWARDED */
+            },
+            16
+            /* FULL_PROPS */
+          ))
+        ],
+        64
+        /* STABLE_FRAGMENT */
+      )) : renderSlot(_ctx.$slots, "default", { key: 1 })
+    ],
+    64
+    /* STABLE_FRAGMENT */
+  )) : createCommentVNode("v-if", true);
+}
+var ItemVue = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/routes-menu-content/src/item/index.vue"]]);
+
+var _sfc_main = defineComponent({
+  name: "VkRoutesMenuContent",
+  components: {
+    ItemVue
+  },
+  props: props$2,
+  emits,
+  setup() {
+    return {
+      resolveFullPath
+    };
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkRoutesMenuContent = resolveComponent("VkRoutesMenuContent");
+  const _component_ItemVue = resolveComponent("ItemVue");
+  return openBlock(true), createElementBlock(
+    Fragment,
+    null,
+    renderList(_ctx.data, (item) => {
+      return openBlock(), createBlock(_component_ItemVue, {
+        key: item.name || item.path,
+        data: item,
+        "popper-class": _ctx.popperClass,
+        "base-path": _ctx.basePath
+      }, {
+        item: withCtx((e) => [
+          renderSlot(_ctx.$slots, "item", mergeProps({ ref_for: true }, e))
+        ]),
+        menuTitle: withCtx((e) => [
+          renderSlot(_ctx.$slots, "menuTitle", mergeProps({ ref_for: true }, e))
+        ]),
+        itemTitle: withCtx((e) => [
+          renderSlot(_ctx.$slots, "itemTitle", mergeProps({ ref_for: true }, e))
+        ]),
+        default: withCtx(() => [
+          createVNode(_component_VkRoutesMenuContent, {
+            data: item.children,
+            "popper-class": _ctx.popperClass,
+            "base-path": _ctx.resolveFullPath(item.path, _ctx.basePath)
+          }, {
+            item: withCtx((e) => [
+              renderSlot(_ctx.$slots, "item", mergeProps({ ref_for: true }, e))
+            ]),
+            menuTitle: withCtx((e) => [
+              renderSlot(_ctx.$slots, "menuTitle", mergeProps({ ref_for: true }, e))
+            ]),
+            itemTitle: withCtx((e) => [
+              renderSlot(_ctx.$slots, "itemTitle", mergeProps({ ref_for: true }, e))
+            ]),
+            _: 2
+            /* DYNAMIC */
+          }, 1032, ["data", "popper-class", "base-path"])
+        ]),
+        _: 2
+        /* DYNAMIC */
+      }, 1032, ["data", "popper-class", "base-path"]);
+    }),
+    128
+    /* KEYED_FRAGMENT */
+  );
+}
+var VkRoutesMenuContent = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/routes-menu-content/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkRoutesMenuContent.install = (app) => {
+  app.component(
+    VkRoutesMenuContent.name || "VkRoutesMenuContent",
+    VkRoutesMenuContent
+  );
+};
+
+export { VkRoutesMenuContent, types as __VkRoutesMenuContent, VkRoutesMenuContent as default };

package/components/routes-menu-content/src/ctx.d.ts

@@ -0,0 +1,17 @@
+import { PropType } from 'vue';
+import type { RouteRecordRaw } from 'vue-router';
+export declare const props: {
+    data: {
+        type: PropType<RouteRecordRaw[]>;
+        default: () => any[];
+    };
+    popperClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    basePath: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export declare const emits: {};

package/components/routes-menu-content/src/index.vue.d.ts

@@ -0,0 +1,350 @@
+import { resolveFullPath } from '@vunk/shared/string/url';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    data: {
+        type: import("vue").PropType<import("vue-router").RouteRecordRaw[]>;
+        default: () => any[];
+    };
+    popperClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    basePath: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {
+    resolveFullPath: typeof resolveFullPath;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: import("vue").PropType<import("vue-router").RouteRecordRaw[]>;
+        default: () => any[];
+    };
+    popperClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    basePath: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    data: import("vue-router").RouteRecordRaw[];
+    popperClass: string;
+    basePath: string;
+}, {}, {
+    ItemVue: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        data: {
+            type: import("vue").PropType<import("vue-router").RouteRecordRaw>;
+            default: () => {};
+        };
+        popperClass: {
+            type: StringConstructor;
+            default: string;
+        };
+        basePath: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        skipRender: symbol;
+        onlyData: import("vue").ComputedRef<{
+            meta: {
+                [x: string]: unknown;
+                [x: number]: unknown;
+                [x: symbol]: unknown;
+            };
+            _paths: string[];
+            path: string;
+            component: import("vue-router").RouteComponent | (() => Promise<import("vue-router").RouteComponent>);
+            components?: never;
+            children?: never;
+            redirect?: never;
+            props?: import("vue-router")._RouteRecordProps<string | symbol>;
+            alias?: string | string[];
+            name?: import("vue-router").RouteRecordName;
+            beforeEnter?: import("vue-router").NavigationGuardWithThis<undefined> | import("vue-router").NavigationGuardWithThis<undefined>[];
+            end?: boolean;
+            sensitive?: boolean;
+            strict?: boolean;
+        } | {
+            meta: {
+                [x: string]: unknown;
+                [x: number]: unknown;
+                [x: symbol]: unknown;
+            };
+            _paths: string[];
+            path: string;
+            component?: import("vue-router").RouteComponent | (() => Promise<import("vue-router").RouteComponent>);
+            components?: never;
+            children: import("vue-router").RouteRecordRaw[];
+            props?: import("vue-router")._RouteRecordProps<string | symbol>;
+            redirect?: import("vue-router").RouteRecordRedirectOption;
+            alias?: string | string[];
+            name?: import("vue-router").RouteRecordName;
+            beforeEnter?: import("vue-router").NavigationGuardWithThis<undefined> | import("vue-router").NavigationGuardWithThis<undefined>[];
+            end?: boolean;
+            sensitive?: boolean;
+            strict?: boolean;
+        } | {
+            meta: {
+                [x: string]: unknown;
+                [x: number]: unknown;
+                [x: symbol]: unknown;
+            };
+            _paths: string[];
+            path: string;
+            components: Record<string, import("vue-router").RouteComponent | (() => Promise<import("vue-router").RouteComponent>)>;
+            component?: never;
+            children?: never;
+            redirect?: never;
+            props?: boolean | Record<string, import("vue-router")._RouteRecordProps<string | symbol>>;
+            alias?: string | string[];
+            name?: import("vue-router").RouteRecordName;
+            beforeEnter?: import("vue-router").NavigationGuardWithThis<undefined> | import("vue-router").NavigationGuardWithThis<undefined>[];
+            end?: boolean;
+            sensitive?: boolean;
+            strict?: boolean;
+        } | {
+            meta: {
+                [x: string]: unknown;
+                [x: number]: unknown;
+                [x: symbol]: unknown;
+            };
+            _paths: string[];
+            path: string;
+            components?: Record<string, import("vue-router").RouteComponent | (() => Promise<import("vue-router").RouteComponent>)>;
+            component?: never;
+            children: import("vue-router").RouteRecordRaw[];
+            props?: boolean | Record<string, import("vue-router")._RouteRecordProps<string | symbol>>;
+            redirect?: import("vue-router").RouteRecordRedirectOption;
+            alias?: string | string[];
+            name?: import("vue-router").RouteRecordName;
+            beforeEnter?: import("vue-router").NavigationGuardWithThis<undefined> | import("vue-router").NavigationGuardWithThis<undefined>[];
+            end?: boolean;
+            sensitive?: boolean;
+            strict?: boolean;
+        } | {
+            meta: {
+                [x: string]: unknown;
+                [x: number]: unknown;
+                [x: symbol]: unknown;
+            };
+            _paths: string[];
+            path: string;
+            redirect: import("vue-router").RouteRecordRedirectOption;
+            component?: never;
+            components?: never;
+            props?: never;
+            alias?: string | string[];
+            name?: import("vue-router").RouteRecordName;
+            beforeEnter?: import("vue-router").NavigationGuardWithThis<undefined> | import("vue-router").NavigationGuardWithThis<undefined>[];
+            children?: import("vue-router").RouteRecordRaw[];
+            end?: boolean;
+            sensitive?: boolean;
+            strict?: boolean;
+        }>;
+        bindProps: import("vue").ComputedRef<{}>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        data: {
+            type: import("vue").PropType<import("vue-router").RouteRecordRaw>;
+            default: () => {};
+        };
+        popperClass: {
+            type: StringConstructor;
+            default: string;
+        };
+        basePath: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        data: import("vue-router").RouteRecordRaw;
+        popperClass: string;
+        basePath: string;
+    }, {}, {
+        CoreVue: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            data: {
+                type: import("vue").PropType<import("vue-router").RouteRecordRaw>;
+                default: () => {};
+            };
+            popperClass: {
+                type: StringConstructor;
+                default: string;
+            };
+            basePath: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            resolveFullPath: typeof resolveFullPath;
+            hasChildren: import("vue").ComputedRef<boolean>;
+            subMenuIndex: import("vue").ComputedRef<string>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            data: {
+                type: import("vue").PropType<import("vue-router").RouteRecordRaw>;
+                default: () => {};
+            };
+            popperClass: {
+                type: StringConstructor;
+                default: string;
+            };
+            basePath: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            data: import("vue-router").RouteRecordRaw;
+            popperClass: string;
+            basePath: string;
+        }, {}, {
+            ElSubMenu: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+                readonly index: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: true;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly showTimeout: NumberConstructor;
+                readonly hideTimeout: NumberConstructor;
+                readonly popperClass: StringConstructor;
+                readonly disabled: BooleanConstructor;
+                readonly teleported: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+                readonly popperOffset: NumberConstructor;
+                readonly expandCloseIcon: {
+                    readonly type: import("vue").PropType<unknown>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly expandOpenIcon: {
+                    readonly type: import("vue").PropType<unknown>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly collapseCloseIcon: {
+                    readonly type: import("vue").PropType<unknown>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly collapseOpenIcon: {
+                    readonly type: import("vue").PropType<unknown>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+            }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+                readonly index: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: true;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly showTimeout: NumberConstructor;
+                readonly hideTimeout: NumberConstructor;
+                readonly popperClass: StringConstructor;
+                readonly disabled: BooleanConstructor;
+                readonly teleported: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+                readonly popperOffset: NumberConstructor;
+                readonly expandCloseIcon: {
+                    readonly type: import("vue").PropType<unknown>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly expandOpenIcon: {
+                    readonly type: import("vue").PropType<unknown>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly collapseCloseIcon: {
+                    readonly type: import("vue").PropType<unknown>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly collapseOpenIcon: {
+                    readonly type: import("vue").PropType<unknown>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+            }>>, {
+                readonly teleported: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+                readonly disabled: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+            ElMenuItem: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+                readonly index: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, null, boolean>;
+                readonly route: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric) | (() => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric) | ((new (...args: any[]) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric) | (() => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+            }, {
+                parentMenu: import("vue").ComputedRef<import("vue").ComponentInternalInstance>;
+                rootMenu: import("element-plus").MenuProvider;
+                active: import("vue").ComputedRef<boolean>;
+                nsMenu: {
+                    namespace: import("vue").ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string) => string;
+                    m: (modifier?: string) => string;
+                    be: (blockSuffix?: string, element?: string) => string;
+                    em: (element?: string, modifier?: string) => string;
+                    bm: (blockSuffix?: string, modifier?: string) => string;
+                    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                    is: {
+                        (name: string, state: boolean): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                nsMenuItem: {
+                    namespace: import("vue").ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string) => string;
+                    m: (modifier?: string) => string;
+                    be: (blockSuffix?: string, element?: string) => string;
+                    em: (element?: string, modifier?: string) => string;
+                    bm: (blockSuffix?: string, modifier?: string) => string;
+                    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                    is: {
+                        (name: string, state: boolean): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                handleClick: () => void;
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (item: import("element-plus").MenuItemRegistered) => boolean;
+            }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+                readonly index: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, null, boolean>;
+                readonly route: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric) | (() => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric) | ((new (...args: any[]) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric) | (() => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+            }>> & {
+                onClick?: (item: import("element-plus").MenuItemRegistered) => any;
+            }, {
+                readonly disabled: boolean;
+                readonly index: string;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;