yuang-framework-ui-pc 1.1.45 → 1.1.46

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

@@ -0,0 +1,323 @@
+import { PropType } from 'vue';
+import { isExternalLink } from '../../utils/core';
+import { MenuItem, MenuItemEvent } from '../types';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** 菜单项数据 */
+    item: {
+        type: PropType<MenuItem>;
+        required: true;
+    };
+    /** 是否需要标题 */
+    showTitle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 是否需要链接 */
+    showLink: BooleanConstructor;
+}>, {
+    isExternalLink: typeof isExternalLink;
+    handleItemClick: MenuItemEvent;
+    handleItemMouseenter: MenuItemEvent;
+    handleItemMouseleave: MenuItemEvent;
+}, {}, {}, {}, 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;
+}>> & Readonly<{
+    onItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+}>, {
+    showLink: boolean;
+    showTitle: boolean;
+}, {}, {
+    ElIcon: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+        readonly size: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly color: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) & import('vue').Plugin;
+    ElBadge: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly value: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly max: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 99;
+            };
+            readonly isDot: BooleanConstructor;
+            readonly hidden: BooleanConstructor;
+            readonly type: {
+                readonly type: PropType<"success" | "primary" | "warning" | "info" | "danger">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "danger";
+            };
+            readonly showZero: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly color: StringConstructor;
+            readonly badgeStyle: {
+                readonly type: PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly offset: {
+                readonly type: PropType<[number, number]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: readonly [0, 0];
+            };
+            readonly badgeClass: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {
+            content: import('vue').ComputedRef<string>;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+            readonly hidden: boolean;
+            readonly offset: [number, number];
+            readonly value: string | number;
+            readonly type: "success" | "primary" | "warning" | "info" | "danger";
+            readonly max: number;
+            readonly showZero: boolean;
+            readonly isDot: boolean;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            readonly value: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly max: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 99;
+            };
+            readonly isDot: BooleanConstructor;
+            readonly hidden: BooleanConstructor;
+            readonly type: {
+                readonly type: PropType<"success" | "primary" | "warning" | "info" | "danger">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "danger";
+            };
+            readonly showZero: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly color: StringConstructor;
+            readonly badgeStyle: {
+                readonly type: PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly offset: {
+                readonly type: PropType<[number, number]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: readonly [0, 0];
+            };
+            readonly badgeClass: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {
+            content: import('vue').ComputedRef<string>;
+        }, {}, {}, {}, {
+            readonly hidden: boolean;
+            readonly offset: [number, number];
+            readonly value: string | number;
+            readonly type: "success" | "primary" | "warning" | "info" | "danger";
+            readonly max: number;
+            readonly showZero: boolean;
+            readonly isDot: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+        readonly value: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly max: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 99;
+        };
+        readonly isDot: BooleanConstructor;
+        readonly hidden: BooleanConstructor;
+        readonly type: {
+            readonly type: PropType<"success" | "primary" | "warning" | "info" | "danger">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "danger";
+        };
+        readonly showZero: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly color: StringConstructor;
+        readonly badgeStyle: {
+            readonly type: PropType<import('vue').StyleValue>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly offset: {
+            readonly type: PropType<[number, number]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: readonly [0, 0];
+        };
+        readonly badgeClass: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>>, {
+        content: import('vue').ComputedRef<string>;
+    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
+        readonly hidden: boolean;
+        readonly offset: [number, number];
+        readonly value: string | number;
+        readonly type: "success" | "primary" | "warning" | "info" | "danger";
+        readonly max: number;
+        readonly showZero: boolean;
+        readonly isDot: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+            content?(_: {
+                value: string;
+            }): any;
+        };
+    }) & import('vue').Plugin;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,108 @@
+import { defineComponent, resolveComponent, createElementBlock, openBlock, Fragment, renderSlot, createCommentVNode, createBlock, createElementVNode, normalizeProps, mergeProps, withCtx, resolveDynamicComponent, normalizeStyle, toDisplayString, withModifiers } from "vue";
+import { ElBadge, ElIcon } 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
+};