@maxtropy/v-components 0.1.12-beta.5 → 0.1.12-beta.6

package/es/components/form/index.d.ts

@@ -0,0 +1,242 @@
+import MxForm from './MxForm.vue';
+import FormItem from './MxFormItem.vue';
+declare module 'vue' {
+    interface GlobalComponents {
+        MxForm: typeof MxForm;
+        MxFormItem: typeof FormItem;
+    }
+}
+export declare const MxFormItem: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            label?: string | undefined;
+            required?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
+            icon?: boolean | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | undefined;
+            labelWidth?: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown> | undefined;
+            inlineMessage?: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown> | undefined;
+            showMessage?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
+            key?: string | number | symbol | undefined;
+            ref?: import("vue").VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            class?: unknown;
+            style?: unknown;
+            readonly error?: string | undefined;
+            readonly size?: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
+            readonly rules?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown> | undefined;
+            readonly prop?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp))[], unknown, unknown> | undefined;
+            readonly validateStatus?: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "success" | "error" | "validating", unknown> | undefined;
+            readonly for?: string | undefined;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            label: {
+                type: StringConstructor;
+                default: string;
+            };
+            icon: {
+                type: import("vue").PropType<boolean | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
+                default: boolean;
+            };
+            labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            prop: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+            rules: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            error: StringConstructor;
+            validateStatus: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "success" | "error" | "validating", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            for: StringConstructor;
+            inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+            showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            size: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            label: string;
+            required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            icon: boolean | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>;
+            labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            inlineMessage: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
+            showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        }, {}, string, {}> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        label: {
+            type: StringConstructor;
+            default: string;
+        };
+        icon: {
+            type: import("vue").PropType<boolean | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
+            default: boolean;
+        };
+        labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+        prop: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+        rules: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        error: StringConstructor;
+        validateStatus: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "success" | "error" | "validating", unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        for: StringConstructor;
+        inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+        showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        size: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    icon: {
+        type: import("vue").PropType<boolean | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
+        default: boolean;
+    };
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "success" | "error" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    label: string;
+    required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    icon: boolean | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>;
+    labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+    inlineMessage: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
+    showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: Partial<Record<NonNullable<string | number>, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>>;
+});
+export default MxForm;

package/es/components/form/index.js

@@ -0,0 +1,12 @@
+import MxForm from "./MxForm.vue";
+import { default as default2 } from "./MxForm.vue";
+import FormItem from "./MxFormItem.vue";
+MxForm.install = (app) => {
+  app.component(MxForm.__name, MxForm);
+  app.component(MxFormItem.__name, FormItem);
+};
+const MxFormItem = FormItem;
+export {
+  MxFormItem,
+  default2 as default
+};

package/es/components/headnavigation/HeadNavigation.css

@@ -0,0 +1,144 @@
+.head-navigation {
+  height: 48px;
+  -webkit-font-smoothing: initial;
+}
+.head-navigation .el-menu {
+  width: 100%;
+  height: 48px;
+  border-bottom-width: 0;
+  padding-left: 0;
+  overflow: auto;
+}
+.head-navigation .el-menu .el-sub-menu {
+  height: 48px;
+}
+.head-navigation .el-menu::before {
+  content: "";
+  width: 15px;
+  display: table;
+}
+.head-navigation .el-menu::after {
+  display: block;
+  clear: both;
+  height: 0;
+  content: " ";
+}
+.head-navigation .el-sub-menu__icon-arrow {
+  display: none;
+}
+.head-navigation .el-icon.el-sub-menu__icon-more svg {
+  width: 10px;
+}
+.head-navigation .el-icon.el-sub-menu__icon-more svg > path {
+  fill: #4a90e2;
+}
+.head-navigation .el-menu--horizontal > .el-sub-menu .el-sub-menu__title {
+  padding: 0 20px;
+  line-height: 48px;
+}
+.navbar-menu-top-popper {
+  width: 920px !important;
+}
+.navbar-menu-top-popper .el-popper__arrow {
+  display: none;
+}
+.navbar-menu-top-popper .el-scrollbar__wrap el-scrollbar__wrap--hidden-default {
+  overflow: hidden !important;
+}
+.navbar-menu-top-popper .el-menu--horizontal {
+  display: block;
+  border-bottom-width: 0;
+  max-height: calc(100vh - 80px);
+  overflow-y: auto;
+}
+.navbar-menu-top-popper .el-scrollbar {
+  border-radius: 3px;
+}
+.navbar-menu-top-popper .el-menu--popup {
+  background: #1b1b1b;
+  box-shadow: none;
+}
+.navbar-menu-top-popper .menu-gorups {
+  display: grid;
+  grid-template-columns: repeat(2, 420px);
+  padding: 20px;
+  grid-row-gap: 35px;
+  grid-column-gap: 20px;
+  padding-bottom: 40px;
+}
+.navbar-menu-top-popper .menu-group-title {
+  margin-bottom: 12px;
+  font-size: 14px;
+  color: rgba(255, 255, 255, 0.85);
+  font-weight: bold;
+  cursor: default;
+}
+.navbar-menu-top-popper .menu-items {
+  display: grid;
+  grid-template-columns: repeat(3, 140px);
+  grid-row-gap: 9px;
+  grid-column-gap: 10px;
+}
+.navbar-menu-top-popper .menu-item_item {
+  position: relative;
+  color: rgba(255, 255, 255, 0.7);
+  padding: 3px 5px;
+  cursor: pointer;
+}
+.navbar-menu-top-popper .menu-item_item > a {
+  height: 100%;
+  color: rgba(255, 255, 255, 0.7);
+  display: flex;
+  align-items: center;
+}
+.navbar-menu-top-popper .menu-item_item > a::before {
+  content: "";
+  display: inline-block;
+  width: 4px;
+  height: 4px;
+  margin-right: 5px;
+  background: rgba(255, 255, 255, 0.7);
+}
+.navbar-menu-top-popper .menu-item_item:hover > a {
+  color: #4a90e2;
+}
+.navbar-menu-top-popper .menu-item_item:hover > a::before {
+  background: #4a90e2;
+}
+.navbar-menu-top-popper .menu-item_item::marker {
+  margin-right: 3px;
+}
+.navbar-menu-top-popper .menu-item_item.is-local {
+  color: #fff;
+  background: #4a90e2;
+  border-radius: 2px;
+  max-width: 110px;
+}
+.navbar-menu-top-popper .menu-item_item.is-local > a {
+  color: #fff;
+}
+.el-menu--horizontal .el-menu.el-menu--popup {
+  padding: 0;
+}
+.el-menu--horizontal .el-menu.el-menu--popup .el-sub-menu__icon-arrow {
+  display: none;
+}
+.el-menu--horizontal .el-menu.el-menu--popup .el-sub-menu__title {
+  padding: 0;
+  color: rgba(255, 255, 255, 0.65);
+}
+.el-menu--horizontal .el-menu.el-menu--popup .el-sub-menu__title:hover {
+  color: #fff;
+}
+.el-menu--horizontal .el-menu.el-menu--popup .el-sub-menu {
+  height: 40px;
+}
+.el-menu--horizontal.el-menu--popup-container {
+  border-bottom-width: 0;
+  background: #1b1b1b;
+  box-shadow: 0 0 50px rgba(0, 0, 0, 0.5);
+  padding: 0 16px;
+}
+.el-popper.is-light {
+  border: none;
+}

package/es/components/headnavigation/HeadNavigation.vue.d.ts

@@ -0,0 +1,45 @@
+import { Router } from 'vue-router';
+import { MenuItem } from '../../common/entity';
+import 'element-plus/es/components/menu/style/css';
+interface Props {
+    devMenu?: MenuItem;
+    customClass?: string;
+    router?: Router | null;
+    activedNodeId?: string;
+}
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    devMenu: undefined;
+    customClass: string;
+    router: null;
+    activedNodeId: undefined;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    devMenu: undefined;
+    customClass: string;
+    router: null;
+    activedNodeId: undefined;
+}>>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+}, {
+    customClass: string;
+    devMenu: MenuItem;
+    router: Router | null;
+    activedNodeId: string;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/es/components/headnavigation/HeadNavigation.vue.js

@@ -0,0 +1,201 @@
+import { defineComponent, computed, ref, watch, openBlock, createElementBlock, normalizeClass, createBlock, unref, withCtx, Fragment, renderList, createVNode, createTextVNode, toDisplayString, createElementVNode, createCommentVNode } from "vue";
+import { useMenuList, useStaffTitle } from "../../utils/hooks";
+import MenuBar from "./MenuBar.vue";
+import "element-plus/es/components/menu/style/css";
+import { ElMenu, ElSubMenu } from "element-plus";
+import "element-plus/es/components/sub-menu/style/css";
+import { cloneDeep } from "lodash-es";
+import { list2Tree, getThirdLevelPathToNodeMap, uniqueSearchKey } from "../../utils/lib";
+import { MenuOpenType } from "../../common/const";
+import { getBase } from "../../utils/micro";
+const _hoisted_1 = { class: "menu-gorups" };
+const _hoisted_2 = { class: "menu-group-title" };
+const _hoisted_3 = { class: "menu-items" };
+const _hoisted_4 = ["href"];
+const _hoisted_5 = ["href"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "HeadNavigation",
+  props: {
+    devMenu: { default: void 0 },
+    customClass: { default: "" },
+    router: { default: null },
+    activedNodeId: { default: void 0 }
+  },
+  emits: ["change"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const insideRouter = computed(() => {
+      if (props == null ? void 0 : props.router)
+        return props == null ? void 0 : props.router;
+      return null;
+    });
+    const getAHref = (path) => {
+      const hasOrigin = /^http/.test(path);
+      let isEqualOrigin = false;
+      let pathname = "";
+      if (hasOrigin) {
+        const url = new URL(path);
+        pathname = url.pathname;
+        isEqualOrigin = url.origin === window.location.origin;
+      }
+      if (isEqualOrigin) {
+        return pathname;
+      }
+      return path;
+    };
+    let prodMenuList = ref([]);
+    useMenuList((list) => prodMenuList.value = list ?? []);
+    const menuList = computed(() => {
+      var _a;
+      if (props.devMenu && process.env.NODE_ENV === "development") {
+        const devMenuList = [];
+        const devMenu2List = (menu) => {
+          devMenuList.push(menu);
+          if (menu.children) {
+            menu.children.forEach((item) => {
+              devMenu2List(item);
+            });
+          }
+        };
+        devMenu2List(cloneDeep(props.devMenu));
+        return (_a = prodMenuList.value) == null ? void 0 : _a.concat(devMenuList);
+      }
+      return prodMenuList.value;
+    });
+    const menuTree = computed(() => {
+      const prodMenuTree = list2Tree(prodMenuList.value);
+      if (props.devMenu && process.env.NODE_ENV === "development") {
+        prodMenuTree.unshift(props.devMenu);
+      }
+      return prodMenuTree;
+    });
+    const path2Node = computed(() => {
+      return getThirdLevelPathToNodeMap(menuList.value);
+    });
+    const activeFirstNode = computed(() => {
+      if (activeThirdNode.value && menuTree) {
+        return menuTree.value.find((item) => {
+          var _a;
+          return item.currentId === ((_a = activeThirdNode.value) == null ? void 0 : _a.rootId);
+        });
+      }
+      return null;
+    });
+    const activeThirdKey = ref();
+    const activeThirdNode = computed(() => {
+      if (activeThirdKey.value) {
+        return path2Node.value[activeThirdKey.value];
+      }
+      return null;
+    });
+    watch(
+      () => activeThirdNode.value,
+      (val) => {
+        useStaffTitle(val == null ? void 0 : val.name);
+      },
+      {
+        immediate: true
+      }
+    );
+    watch(
+      () => {
+        var _a, _b;
+        return (_b = (_a = insideRouter.value) == null ? void 0 : _a.currentRoute) == null ? void 0 : _b.value;
+      },
+      () => {
+        var _a, _b;
+        const { hash, pathname } = window.location;
+        const base = getBase();
+        const sliceIndex = base ? [3, 6] : [0, 4];
+        let currentPath = pathname;
+        if (hash) {
+          currentPath = hash.replace("#", "").split("/").slice(...sliceIndex).join("/");
+        } else {
+          currentPath = pathname.split("/").slice(...sliceIndex).join("/");
+        }
+        const uniqueSearchValue = (_b = (_a = insideRouter.value) == null ? void 0 : _a.currentRoute) == null ? void 0 : _b.value.query[uniqueSearchKey];
+        if (uniqueSearchValue)
+          currentPath += `?${uniqueSearchKey}=${uniqueSearchValue}`;
+        activeThirdKey.value = currentPath;
+      },
+      {
+        immediate: true
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["head-navigation", props == null ? void 0 : props.customClass])
+      }, [
+        menuTree.value.length ? (openBlock(), createBlock(unref(ElMenu), {
+          key: 0,
+          ref: "menuItem",
+          mode: "horizontal",
+          ellipsis: "",
+          "text-color": "rgba(255,255,255,0.65)",
+          "background-color": "#1b1b1b"
+        }, {
+          default: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(menuTree.value, (menu) => {
+              return openBlock(), createBlock(unref(ElSubMenu), {
+                key: menu.currentId,
+                index: menu.currentId,
+                "popper-offset": 4,
+                "popper-class": "navbar-menu-top-popper"
+              }, {
+                title: withCtx(() => {
+                  var _a;
+                  return [
+                    createVNode(MenuBar, {
+                      actived: menu.currentId === ((_a = activeFirstNode.value) == null ? void 0 : _a.currentId) || (props == null ? void 0 : props.activedNodeId) === menu.currentId
+                    }, {
+                      default: withCtx(() => [
+                        createTextVNode(toDisplayString(menu.name), 1)
+                      ]),
+                      _: 2
+                    }, 1032, ["actived"])
+                  ];
+                }),
+                default: withCtx(() => [
+                  createElementVNode("li", _hoisted_1, [
+                    (openBlock(true), createElementBlock(Fragment, null, renderList(menu.children, (menu2) => {
+                      return openBlock(), createElementBlock("div", {
+                        key: menu2.currentId,
+                        class: "menu-group"
+                      }, [
+                        createElementVNode("div", _hoisted_2, toDisplayString(menu2.name), 1),
+                        createElementVNode("ul", _hoisted_3, [
+                          (openBlock(true), createElementBlock(Fragment, null, renderList(menu2.children, (menu3) => {
+                            var _a;
+                            return openBlock(), createElementBlock("li", {
+                              key: menu3.currentId,
+                              class: normalizeClass(["menu-item_item", { "is-local": ((_a = activeThirdNode.value) == null ? void 0 : _a.currentId) === menu3.currentId }])
+                            }, [
+                              menu3.openType === unref(MenuOpenType).CurrentPage ? (openBlock(), createElementBlock("a", {
+                                key: 0,
+                                href: getAHref(menu3.transitPagePath)
+                              }, toDisplayString(menu3.name), 9, _hoisted_4)) : (openBlock(), createElementBlock("a", {
+                                key: 1,
+                                href: menu3.transitPagePath,
+                                target: "_blank"
+                              }, toDisplayString(menu3.name), 9, _hoisted_5))
+                            ], 2);
+                          }), 128))
+                        ])
+                      ]);
+                    }), 128))
+                  ])
+                ]),
+                _: 2
+              }, 1032, ["index"]);
+            }), 128))
+          ]),
+          _: 1
+        }, 512)) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+const HeadNavigation_vue_vue_type_style_index_0_lang = "";
+export {
+  _sfc_main as default
+};