ele-admin-plus 1.1.9-beta.1 → 1.1.9-beta.11

package/lib/ele-pro-layout/components/pro-header.cjs

@@ -4,9 +4,10 @@ const icons = require("../../icons");
 const EleBreadcrumb = require("../../ele-breadcrumb/index");
 const EleMenus = require("../../ele-menus/index");
 const util = require("../util");
+const ProTabs = require("./pro-tabs");
 const _sfc_main = vue.defineComponent({
   name: "ProHeader",
-  components: { EleBreadcrumb, EleMenus },
+  components: { EleBreadcrumb, EleMenus, ProTabs },
   props: {
     /** 菜单数据 */
     menus: {
@@ -21,17 +22,17 @@ const _sfc_main = vue.defineComponent({
     ellipsis: Boolean,
     /** 菜单省略项的属性 */
     ellipsisProps: Object,
-    /** 子菜单触发方式 */
+    /** 父级菜单展开触发方式 */
     menuTrigger: String,
-    /** 菜单项触发模式 */
+    /** 子菜单项触发模式 */
     itemTrigger: String,
     /** 侧栏是否折叠 */
     collapse: Boolean,
     /** 当前是否有侧栏 */
     sidebar: Boolean,
-    /** 标题插槽名称 */
+    /** 菜单标题插槽名称 */
     titleSlot: String,
-    /** 图标插槽名称 */
+    /** 菜单图标插槽名称 */
     iconSlot: String,
     /** 面包屑导航数据 */
     levels: {
@@ -45,24 +46,61 @@ const _sfc_main = vue.defineComponent({
     /** 主页路由地址 */
     homePath: String,
     /** 当前路由是否是主页 */
-    isHome: Boolean
+    isHome: Boolean,
+    /** 是否开启菜单文本溢出提示 */
+    menuTextEllipsisTooltip: [Boolean, Object],
+    /** 页签数据 */
+    tabs: {
+      type: Array,
+      required: true
+    },
+    /** 页签选中 */
+    tabActive: {
+      type: String,
+      required: true
+    },
+    /** 是否需要固定的主页页签 */
+    fixedHome: Boolean,
+    /** 页签风格 */
+    tabStyle: String,
+    /** 是否支持右键菜单 */
+    tabContextMenu: [Boolean, Object],
+    /** 右键菜单 */
+    tabContextMenus: [Array, Function],
+    /** 是否支持拖动排序 */
+    tabSortable: Boolean,
+    /** 是否需要页签栏 */
+    tabBar: [Boolean, String]
   },
   emits: {
     logoClick: () => true,
     open: (_index, _indexPath) => true,
     close: (_index, _indexPath) => true,
-    itemClick: (_item) => true
+    itemClick: (_item, _e) => true,
+    itemMouseenter: (_item, _e) => true,
+    itemMouseleave: (_item, _e) => true,
+    mouseEnter: (_e) => true,
+    mouseLeave: (_e) => true,
+    tabClick: (_opt) => true,
+    tabRemove: (_opt) => true,
+    tabContextMenu: (_opt) => true,
+    tabSortChange: (_data) => true
   },
   setup(props, { emit }) {
+    const state = { hover: false, timer: null };
     const levelItems = vue.shallowRef([]);
     const menuItems = vue.computed(() => {
-      return util.getMenuItems(props.menus, props.itemTrigger != "click");
+      return util.getMenuItems(
+        props.menus,
+        props.itemTrigger !== "click" && props.itemTrigger !== "hover"
+      );
     });
     const isDark = vue.computed(() => props.headerStyle === "dark");
     const isPrimary = vue.computed(() => props.headerStyle === "primary");
     const isIconSeparator = vue.computed(() => {
       return typeof props.breadcrumbSeparator !== "string";
     });
+    const hasTab = vue.computed(() => props.tabBar === "header");
     const onLogoClick = () => {
       emit("logoClick");
     };
@@ -72,8 +110,48 @@ const _sfc_main = vue.defineComponent({
     const onClose = (index, indexPath) => {
       emit("close", index, indexPath);
     };
-    const onItemClick = (item) => {
-      emit("itemClick", item);
+    const onItemClick = (item, e) => {
+      emit("itemClick", item, e);
+    };
+    const onItemMouseenter = (item, e) => {
+      emit("itemMouseenter", item, e);
+      onMouseenter(e);
+    };
+    const onItemMouseleave = (item, e) => {
+      emit("itemMouseleave", item, e);
+      onMouseleave(e);
+    };
+    const onMouseenter = (e) => {
+      if (state.timer != null) {
+        clearTimeout(state.timer);
+        state.timer = null;
+      }
+      if (!state.hover) {
+        state.hover = true;
+        emit("mouseEnter", e);
+      }
+    };
+    const onMouseleave = (e) => {
+      if (state.timer != null) {
+        clearTimeout(state.timer);
+      }
+      state.timer = setTimeout(() => {
+        state.timer = null;
+        state.hover = false;
+        emit("mouseLeave", e);
+      }, 300);
+    };
+    const onTabClick = (opt) => {
+      emit("tabClick", opt);
+    };
+    const onTabRemove = (opt) => {
+      emit("tabRemove", opt);
+    };
+    const onTabContextMenu = (opt) => {
+      emit("tabContextMenu", opt);
+    };
+    const onTabSortChange = (data) => {
+      emit("tabSortChange", data);
     };
     vue.watch(
       [() => props.isHome, () => props.homePath, () => props.levels],
@@ -95,18 +173,36 @@ const _sfc_main = vue.defineComponent({
         });
         levelItems.value = data;
       },
-      { deep: true, immediate: true }
+      {
+        immediate: true,
+        deep: true
+      }
     );
+    vue.onBeforeUnmount(() => {
+      if (state.timer != null) {
+        clearTimeout(state.timer);
+        state.timer = null;
+      }
+    });
     return {
       levelItems,
       menuItems,
       isDark,
       isPrimary,
       isIconSeparator,
+      hasTab,
       onLogoClick,
       onOpen,
       onClose,
-      onItemClick
+      onItemClick,
+      onItemMouseenter,
+      onItemMouseleave,
+      onMouseenter,
+      onMouseleave,
+      onTabClick,
+      onTabRemove,
+      onTabContextMenu,
+      onTabSortChange
     };
   }
 });
@@ -125,20 +221,27 @@ const _hoisted_2 = {
   key: 2,
   class: "ele-admin-breadcrumb"
 };
-const _hoisted_3 = { class: "ele-admin-menus" };
-const _hoisted_4 = {
+const _hoisted_3 = {
   key: 3,
+  class: "ele-admin-menus"
+};
+const _hoisted_4 = {
+  key: 5,
   class: "ele-admin-tools"
 };
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_EleBreadcrumb = vue.resolveComponent("EleBreadcrumb");
   const _component_EleMenus = vue.resolveComponent("EleMenus");
+  const _component_ProTabs = vue.resolveComponent("ProTabs");
   return vue.openBlock(), vue.createElementBlock("div", {
     class: vue.normalizeClass([
       "ele-admin-header",
       { "is-dark": _ctx.isDark },
-      { "is-primary": _ctx.isPrimary }
-    ])
+      { "is-primary": _ctx.isPrimary },
+      { "is-ghost": !_ctx.isDark && !_ctx.isPrimary && _ctx.hasTab && _ctx.tabStyle === "button" }
+    ]),
+    onMouseenter: _cache[1] || (_cache[1] = (...args) => _ctx.onMouseenter && _ctx.onMouseenter(...args)),
+    onMouseleave: _cache[2] || (_cache[2] = (...args) => _ctx.onMouseleave && _ctx.onMouseleave(...args))
   }, [
     _ctx.$slots.logo ? (vue.openBlock(), vue.createElementBlock("div", {
       key: 0,
@@ -168,7 +271,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
       ])
     ])) : vue.createCommentVNode("", true),
     vue.renderSlot(_ctx.$slots, "center", { sidebar: _ctx.sidebar }),
-    vue.createElementVNode("div", _hoisted_3, [
+    _ctx.menuItems.length || !_ctx.hasTab ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, [
       _ctx.menuItems.length ? (vue.openBlock(), vue.createBlock(_component_EleMenus, {
         key: 0,
         items: _ctx.menuItems,
@@ -179,34 +282,80 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
         ellipsisProps: _ctx.ellipsisProps,
         defaultActive: _ctx.active,
         menuTrigger: _ctx.menuTrigger,
+        textEllipsisTooltip: _ctx.menuTextEllipsisTooltip,
         onOpen: _ctx.onOpen,
         onClose: _ctx.onClose,
-        onItemClick: _ctx.onItemClick
+        onItemClick: _ctx.onItemClick,
+        onItemMouseenter: _ctx.onItemMouseenter,
+        onItemMouseleave: _ctx.onItemMouseleave
       }, vue.createSlots({ _: 2 }, [
-        _ctx.iconSlot && !["logo", "left", "right", "center", "breadcrumb"].includes(
-          _ctx.iconSlot
-        ) && _ctx.$slots[_ctx.iconSlot] ? {
+        _ctx.iconSlot && ![
+          "logo",
+          "left",
+          "right",
+          "center",
+          "breadcrumb",
+          "tabTitle",
+          "tabContext",
+          "tabExtra",
+          "tabHome"
+        ].includes(_ctx.iconSlot) && _ctx.$slots[_ctx.iconSlot] ? {
           name: "icon",
           fn: vue.withCtx((slotProps) => [
             vue.renderSlot(_ctx.$slots, _ctx.iconSlot, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
           ]),
           key: "0"
         } : void 0,
-        _ctx.titleSlot && !["logo", "left", "right", "center", "breadcrumb"].includes(
-          _ctx.titleSlot
-        ) && _ctx.$slots[_ctx.titleSlot] ? {
+        _ctx.titleSlot && ![
+          "logo",
+          "left",
+          "right",
+          "center",
+          "breadcrumb",
+          "tabTitle",
+          "tabContext",
+          "tabExtra",
+          "tabHome"
+        ].includes(_ctx.titleSlot) && _ctx.$slots[_ctx.titleSlot] ? {
           name: "title",
           fn: vue.withCtx((slotProps) => [
             vue.renderSlot(_ctx.$slots, _ctx.titleSlot, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
           ]),
           key: "1"
         } : void 0
-      ]), 1032, ["items", "theme", "popupTheme", "ellipsis", "ellipsisProps", "defaultActive", "menuTrigger", "onOpen", "onClose", "onItemClick"])) : vue.createCommentVNode("", true)
-    ]),
+      ]), 1032, ["items", "theme", "popupTheme", "ellipsis", "ellipsisProps", "defaultActive", "menuTrigger", "textEllipsisTooltip", "onOpen", "onClose", "onItemClick", "onItemMouseenter", "onItemMouseleave"])) : vue.createCommentVNode("", true)
+    ])) : vue.createCommentVNode("", true),
+    _ctx.hasTab ? (vue.openBlock(), vue.createBlock(_component_ProTabs, {
+      key: 4,
+      tabs: _ctx.tabs,
+      active: _ctx.tabActive,
+      tabStyle: _ctx.tabStyle,
+      fixedHome: _ctx.fixedHome,
+      homePath: _ctx.homePath,
+      isHome: _ctx.isHome,
+      tabContextMenu: _ctx.tabContextMenu,
+      tabContextMenus: _ctx.tabContextMenus,
+      tabSortable: _ctx.tabSortable,
+      onTabClick: _ctx.onTabClick,
+      onTabRemove: _ctx.onTabRemove,
+      onTabContextMenu: _ctx.onTabContextMenu,
+      onTabSortChange: _ctx.onTabSortChange
+    }, vue.createSlots({ _: 2 }, [
+      vue.renderList(Object.keys(_ctx.$slots).filter(
+        (k) => ["tabTitle", "tabContext", "tabExtra", "tabHome"].includes(k)
+      ), (name) => {
+        return {
+          name,
+          fn: vue.withCtx((slotProps) => [
+            vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+          ])
+        };
+      })
+    ]), 1032, ["tabs", "active", "tabStyle", "fixedHome", "homePath", "isHome", "tabContextMenu", "tabContextMenus", "tabSortable", "onTabClick", "onTabRemove", "onTabContextMenu", "onTabSortChange"])) : vue.createCommentVNode("", true),
     _ctx.$slots.right ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_4, [
       vue.renderSlot(_ctx.$slots, "right", { sidebar: _ctx.sidebar })
     ])) : vue.createCommentVNode("", true)
-  ], 2);
+  ], 34);
 }
 const proHeader = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 module.exports = proHeader;

package/lib/ele-pro-layout/components/pro-header.d.ts

@@ -1,8 +1,10 @@
-import type { PropType } from 'vue';
+import { MenuItem, LevelItem, HeaderStyle, MenuItemTrigger, MenuItemProps, TabStyle, TabItem, TabItemEventOption } from '../types';
+import { ContextMenus } from '../../ele-tabs/types';
+import { EleDropdownProps } from '../../ele-app/plus';
 import { BreadcrumbItem } from '../../ele-breadcrumb/types';
-import type { EllipsisProps } from '../../ele-menus/types';
-import type { MenuItem, LevelItem, HeaderStyle, MenuItemTrigger, MenuItemProps } from '../types';
-declare const _default: import("vue").DefineComponent<{
+import { PropType } from 'vue';
+
+declare const _default: import('vue').DefineComponent<{
     /** 菜单数据 */
     menus: {
         type: PropType<MenuItem[]>;
@@ -15,18 +17,18 @@ declare const _default: import("vue").DefineComponent<{
     /** 菜单是否省略多余的子项 */
     ellipsis: BooleanConstructor;
     /** 菜单省略项的属性 */
-    ellipsisProps: PropType<EllipsisProps>;
-    /** 子菜单触发方式 */
+    ellipsisProps: PropType<import("../../ele-menus/types").EllipsisProps | undefined>;
+    /** 父级菜单展开触发方式 */
     menuTrigger: PropType<import("element-plus/es/utils/index").EpPropMergeType<StringConstructor, "hover" | "click", unknown> | undefined>;
-    /** 菜单项触发模式 */
+    /** 子菜单项触发模式 */
     itemTrigger: PropType<MenuItemTrigger>;
     /** 侧栏是否折叠 */
     collapse: BooleanConstructor;
     /** 当前是否有侧栏 */
     sidebar: BooleanConstructor;
-    /** 标题插槽名称 */
+    /** 菜单标题插槽名称 */
     titleSlot: StringConstructor;
-    /** 图标插槽名称 */
+    /** 菜单图标插槽名称 */
     iconSlot: StringConstructor;
     /** 面包屑导航数据 */
     levels: {
@@ -41,21 +43,62 @@ declare const _default: import("vue").DefineComponent<{
     homePath: StringConstructor;
     /** 当前路由是否是主页 */
     isHome: BooleanConstructor;
+    /** 是否开启菜单文本溢出提示 */
+    menuTextEllipsisTooltip: PropType<boolean | Partial<import("../../ele-tooltip/props").TooltipProps> | undefined>;
+    /** 页签数据 */
+    tabs: {
+        type: PropType<TabItem[]>;
+        required: true;
+    };
+    /** 页签选中 */
+    tabActive: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** 是否需要固定的主页页签 */
+    fixedHome: BooleanConstructor;
+    /** 页签风格 */
+    tabStyle: PropType<TabStyle>;
+    /** 是否支持右键菜单 */
+    tabContextMenu: PropType<boolean | EleDropdownProps>;
+    /** 右键菜单 */
+    tabContextMenus: PropType<ContextMenus>;
+    /** 是否支持拖动排序 */
+    tabSortable: BooleanConstructor;
+    /** 是否需要页签栏 */
+    tabBar: PropType<boolean | "header">;
 }, {
     levelItems: import("vue").ShallowRef<BreadcrumbItem[]>;
     menuItems: import("vue").ComputedRef<Partial<import("../../ele-menus/types").MenuItem>[]>;
     isDark: import("vue").ComputedRef<boolean>;
     isPrimary: import("vue").ComputedRef<boolean>;
     isIconSeparator: import("vue").ComputedRef<boolean>;
+    hasTab: import("vue").ComputedRef<boolean>;
     onLogoClick: () => void;
     onOpen: (index: string, indexPath: string[]) => void;
     onClose: (index: string, indexPath: string[]) => void;
-    onItemClick: (item: MenuItemProps) => void;
+    onItemClick: (item: MenuItemProps, e: MouseEvent) => void;
+    onItemMouseenter: (item: MenuItemProps, e: MouseEvent) => void;
+    onItemMouseleave: (item: MenuItemProps, e: MouseEvent) => void;
+    onMouseenter: (e: MouseEvent) => void;
+    onMouseleave: (e: MouseEvent) => void;
+    onTabClick: (opt: TabItemEventOption) => void;
+    onTabRemove: (opt: TabItemEventOption) => void;
+    onTabContextMenu: (opt: TabItemEventOption) => void;
+    onTabSortChange: (data: TabItem[]) => void;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     logoClick: () => true;
     open: (_index: string, _indexPath: string[]) => true;
     close: (_index: string, _indexPath: string[]) => true;
-    itemClick: (_item: MenuItemProps) => true;
+    itemClick: (_item: MenuItemProps, _e: MouseEvent) => true;
+    itemMouseenter: (_item: MenuItemProps, _e: MouseEvent) => true;
+    itemMouseleave: (_item: MenuItemProps, _e: MouseEvent) => true;
+    mouseEnter: (_e: MouseEvent) => true;
+    mouseLeave: (_e: MouseEvent) => true;
+    tabClick: (_opt: TabItemEventOption) => true;
+    tabRemove: (_opt: TabItemEventOption) => true;
+    tabContextMenu: (_opt: TabItemEventOption) => true;
+    tabSortChange: (_data: TabItem[]) => true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     /** 菜单数据 */
     menus: {
@@ -69,18 +112,18 @@ declare const _default: import("vue").DefineComponent<{
     /** 菜单是否省略多余的子项 */
     ellipsis: BooleanConstructor;
     /** 菜单省略项的属性 */
-    ellipsisProps: PropType<EllipsisProps>;
-    /** 子菜单触发方式 */
+    ellipsisProps: PropType<import("../../ele-menus/types").EllipsisProps | undefined>;
+    /** 父级菜单展开触发方式 */
     menuTrigger: PropType<import("element-plus/es/utils/index").EpPropMergeType<StringConstructor, "hover" | "click", unknown> | undefined>;
-    /** 菜单项触发模式 */
+    /** 子菜单项触发模式 */
     itemTrigger: PropType<MenuItemTrigger>;
     /** 侧栏是否折叠 */
     collapse: BooleanConstructor;
     /** 当前是否有侧栏 */
     sidebar: BooleanConstructor;
-    /** 标题插槽名称 */
+    /** 菜单标题插槽名称 */
     titleSlot: StringConstructor;
-    /** 图标插槽名称 */
+    /** 菜单图标插槽名称 */
     iconSlot: StringConstructor;
     /** 面包屑导航数据 */
     levels: {
@@ -95,16 +138,50 @@ declare const _default: import("vue").DefineComponent<{
     homePath: StringConstructor;
     /** 当前路由是否是主页 */
     isHome: BooleanConstructor;
+    /** 是否开启菜单文本溢出提示 */
+    menuTextEllipsisTooltip: PropType<boolean | Partial<import("../../ele-tooltip/props").TooltipProps> | undefined>;
+    /** 页签数据 */
+    tabs: {
+        type: PropType<TabItem[]>;
+        required: true;
+    };
+    /** 页签选中 */
+    tabActive: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** 是否需要固定的主页页签 */
+    fixedHome: BooleanConstructor;
+    /** 页签风格 */
+    tabStyle: PropType<TabStyle>;
+    /** 是否支持右键菜单 */
+    tabContextMenu: PropType<boolean | EleDropdownProps>;
+    /** 右键菜单 */
+    tabContextMenus: PropType<ContextMenus>;
+    /** 是否支持拖动排序 */
+    tabSortable: BooleanConstructor;
+    /** 是否需要页签栏 */
+    tabBar: PropType<boolean | "header">;
 }>> & {
     onOpen?: ((_index: string, _indexPath: string[]) => any) | undefined;
     onClose?: ((_index: string, _indexPath: string[]) => any) | undefined;
-    onItemClick?: ((_item: Partial<import("../../ele-menus/types").MenuItem>) => any) | undefined;
+    onTabClick?: ((_opt: TabItemEventOption) => any) | undefined;
+    onTabRemove?: ((_opt: TabItemEventOption) => any) | undefined;
+    onItemClick?: ((_item: Partial<import("../../ele-menus/types").MenuItem>, _e: MouseEvent) => any) | undefined;
+    onTabContextMenu?: ((_opt: TabItemEventOption) => any) | undefined;
+    onTabSortChange?: ((_data: TabItem[]) => any) | undefined;
+    onItemMouseenter?: ((_item: Partial<import("../../ele-menus/types").MenuItem>, _e: MouseEvent) => any) | undefined;
+    onItemMouseleave?: ((_item: Partial<import("../../ele-menus/types").MenuItem>, _e: MouseEvent) => any) | undefined;
     onLogoClick?: (() => any) | undefined;
+    onMouseEnter?: ((_e: MouseEvent) => any) | undefined;
+    onMouseLeave?: ((_e: MouseEvent) => any) | undefined;
 }, {
     collapse: boolean;
     ellipsis: boolean;
     breadcrumb: boolean;
     sidebar: boolean;
+    fixedHome: boolean;
+    tabSortable: boolean;
     isHome: boolean;
 }, {}>;
 export default _default;

package/lib/ele-pro-layout/components/pro-iframe.cjs

@@ -22,20 +22,22 @@ const _sfc_main = vue.defineComponent({
     const visible = vue.ref(false);
     const active = vue.ref(null);
     const data = vue.computed(() => {
-      const result = [];
+      const list = [];
       props.tabData.forEach((t) => {
         var _a, _b;
         const isAlive = ((_a = t.meta) == null ? void 0 : _a.keepAlive) !== false;
-        if (t.key && ((_b = t.meta) == null ? void 0 : _b.iframe) && !t.refresh && isAlive) {
-          result.push({ id: t.key, src: t.meta.iframe });
+        if (t.key && ((_b = t.meta) == null ? void 0 : _b.iframe) && isAlive) {
+          list.push({ id: t.key, src: t.meta.iframe, refresh: t.refresh });
         }
       });
-      return result;
+      return list.sort((a, b) => a.id === b.id ? 0 : a.id > b.id ? 1 : -1);
     });
     const onAfterLeave = (delay) => {
       if (props.tabActive && data.value.length && data.value.some((d) => d.id === props.tabActive)) {
         if (delay) {
+          clearTimer();
           state.timer = setTimeout(() => {
+            state.timer = null;
             visible.value = true;
             vue.nextTick(() => {
               active.value = props.tabActive;
@@ -43,9 +45,7 @@ const _sfc_main = vue.defineComponent({
           }, delay);
         } else {
           visible.value = true;
-          vue.nextTick(() => {
-            active.value = props.tabActive;
-          });
+          active.value = props.tabActive;
         }
       } else {
         visible.value = false;
@@ -53,7 +53,7 @@ const _sfc_main = vue.defineComponent({
       }
     };
     const clearTimer = () => {
-      if (state.timer) {
+      if (state.timer != null) {
         clearTimeout(state.timer);
         state.timer = null;
       }
@@ -63,10 +63,14 @@ const _sfc_main = vue.defineComponent({
       () => {
         clearTimer();
         if (visible.value) {
-          active.value = null;
-        } else {
-          onAfterLeave(props.transitionDelay);
+          if (!props.transitionName) {
+            onAfterLeave();
+          } else {
+            active.value = null;
+          }
+          return;
         }
+        onAfterLeave(props.transitionName ? props.transitionDelay : void 0);
       }
     );
     vue.onBeforeUnmount(() => {
@@ -88,28 +92,47 @@ const _export_sfc = (sfc, props) => {
   return target;
 };
 const _hoisted_1 = { class: "ele-admin-iframe-wrap" };
-const _hoisted_2 = ["id", "src"];
+const _hoisted_2 = ["data-id", "src"];
+const _hoisted_3 = ["data-id", "src"];
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
-    vue.createVNode(vue.TransitionGroup, {
+    !_ctx.transitionName ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(_ctx.data, (item) => {
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+        key: item.id
+      }, [
+        !item.refresh ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("iframe", {
+          key: 0,
+          "data-id": item.id,
+          src: item.src,
+          class: "ele-admin-iframe"
+        }, null, 8, _hoisted_2)), [
+          [vue.vShow, _ctx.active === item.id]
+        ]) : vue.createCommentVNode("", true)
+      ], 64);
+    }), 128)) : (vue.openBlock(), vue.createBlock(vue.TransitionGroup, {
+      key: 1,
       appear: true,
       name: _ctx.transitionName,
       onAfterLeave: _cache[0] || (_cache[0] = ($event) => _ctx.onAfterLeave())
     }, {
       default: vue.withCtx(() => [
         (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.data, (item) => {
-          return vue.withDirectives((vue.openBlock(), vue.createElementBlock("iframe", {
-            key: item.id,
-            id: item.id,
-            src: item.src,
-            class: "ele-admin-iframe"
-          }, null, 8, _hoisted_2)), [
-            [vue.vShow, _ctx.active === item.id]
-          ]);
+          return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+            key: item.id
+          }, [
+            !item.refresh ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("iframe", {
+              key: 0,
+              "data-id": item.id,
+              src: item.src,
+              class: "ele-admin-iframe"
+            }, null, 8, _hoisted_3)), [
+              [vue.vShow, _ctx.active === item.id]
+            ]) : vue.createCommentVNode("", true)
+          ], 64);
         }), 128))
       ]),
       _: 1
-    }, 8, ["name"])
+    }, 8, ["name"]))
   ], 512)), [
     [vue.vShow, _ctx.visible]
   ]);

package/lib/ele-pro-layout/components/pro-iframe.d.ts

@@ -1,6 +1,7 @@
-import type { PropType } from 'vue';
-import type { TabItem, IframeItem } from '../types';
-declare const _default: import("vue").DefineComponent<{
+import { TabItem, IframeItem } from '../types';
+import { PropType } from 'vue';
+
+declare const _default: import('vue').DefineComponent<{
     /** 是否支持内链缓存 */
     keepAlive: BooleanConstructor;
     /** 内链切换动画 */