ele-admin-plus 1.0.2 → 1.1.0

package/es/ele-table-select/style/index.scss

@@ -1,9 +1,22 @@
 @use '../../style/themes/default.scss' as *;
+@use '../../style/util.scss' as *;
+@use './css-var.scss' as *;
+
+@include set-table-select-var($ele);
 
 .ele-table-select-popper {
-  #{elVarName('popover', 'padding')}: 8px;
+  & > .ele-popover-body > .ele-popover-content {
+    padding: eleVar('table-select', 'padding');
+
+    & > .ele-pro-table {
+      #{eleVarName('table', 'th-bg')}: eleVar('table-select', 'th-bg');
+      #{eleVarName('table', 'tr-bg')}: eleVar('table-select', 'tr-bg');
+      #{eleVarName('table', 'even-bg')}: eleVar('table-select', 'even-bg');
+      #{eleVarName('table', 'bg')}: eleVar('table-select', 'tr-bg');
+    }
+  }
 
   &.is-responsive {
-    max-width: calc(100vw - 32px);
+    max-width: calc(100vw - #{eleVar('table-select', 'mobile-space')} * 2);
   }
 }

package/es/ele-table-select/types/index.d.ts

@@ -13,7 +13,10 @@ export type MultipleInitValue = Array<SingleInitValue>;
  */
 export type InitValue = SingleInitValue | MultipleInitValue | undefined | null;
 /**
- * 组件实例
+ * 高级表格组件实例
  */
 export type EleProTableInstance = InstanceType<typeof EleProTable> | null;
+/**
+ * 通用下拉选择组件实例
+ */
 export type EleBasicSelectInstance = InstanceType<typeof EleBasicSelect> | null;

package/es/ele-tabs/components/tab-title.d.ts

@@ -1,35 +1,37 @@
 import type { PropType } from 'vue';
-import type { ElDropdownInstance } from '../../ele-app/types';
+import type { DropdownItem } from '../../ele-dropdown/types';
+import type { EleDropdownProps, DropdownInstance } from '../../ele-file-list/types';
 import type { TabPaneItem, TabEventOption } from '../types';
-declare const _sfc_main: import("vue").DefineComponent<{
+declare const _default: import("vue").DefineComponent<{
     active: (StringConstructor | NumberConstructor)[];
     tabName: (StringConstructor | NumberConstructor)[];
     label: StringConstructor;
     item: PropType<TabPaneItem>;
-    contextMenu: BooleanConstructor;
+    contextMenu: PropType<boolean | EleDropdownProps>;
+    contextMenus: PropType<DropdownItem[]>;
     handleClick: BooleanConstructor;
 }, {
-    dropdownRef: import("vue").Ref<ElDropdownInstance>;
+    dropdownRef: import("vue").Ref<DropdownInstance>;
     onContextMenu: (command: string) => void;
     onContextVisible: (visible: boolean) => void;
     onClick: (e: MouseEvent) => void;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     itemClick: (_opt: TabEventOption) => true;
     contextMenu: (_option: TabEventOption) => true;
-    contextOpen: (_ref: ElDropdownInstance) => true;
+    contextOpen: (_ref: DropdownInstance) => true;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     active: (StringConstructor | NumberConstructor)[];
     tabName: (StringConstructor | NumberConstructor)[];
     label: StringConstructor;
     item: PropType<TabPaneItem>;
-    contextMenu: BooleanConstructor;
+    contextMenu: PropType<boolean | EleDropdownProps>;
+    contextMenus: PropType<DropdownItem[]>;
     handleClick: BooleanConstructor;
 }>> & {
     onItemClick?: ((_opt: TabEventOption) => any) | undefined;
     onContextMenu?: ((_option: TabEventOption) => any) | undefined;
-    onContextOpen?: ((_ref: ElDropdownInstance) => any) | undefined;
+    onContextOpen?: ((_ref: DropdownInstance) => any) | undefined;
 }, {
-    contextMenu: boolean;
     handleClick: boolean;
 }, {}>;
-export default _sfc_main;
+export default _default;

package/es/ele-tabs/components/tab-title.js

@@ -1,8 +1,8 @@
-import { defineComponent, ref, resolveComponent, openBlock, createBlock, withCtx, renderSlot, createCommentVNode, createElementVNode, createTextVNode, toDisplayString } from "vue";
-import { ElDropdown, ElDropdownMenu } from "element-plus";
+import { defineComponent, ref, resolveComponent, openBlock, createBlock, mergeProps, createSlots, withCtx, createElementVNode, renderSlot, createTextVNode, toDisplayString } from "vue";
+import EleDropdown from "../../ele-dropdown/index";
 const _sfc_main = defineComponent({
   name: "TabTitle",
-  components: { ElDropdown, ElDropdownMenu },
+  components: { EleDropdown },
   props: {
     // 当前选中页签
     active: [String, Number],
@@ -13,7 +13,9 @@ const _sfc_main = defineComponent({
     // 页签数据
     item: Object,
     // 是否支持右键菜单
-    contextMenu: Boolean,
+    contextMenu: [Boolean, Object],
+    // 右键菜单
+    contextMenus: Array,
     // 是否自己处理页签点击事件
     handleClick: Boolean
   },
@@ -58,29 +60,20 @@ const _export_sfc = (sfc, props) => {
   return target;
 };
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_ElDropdownMenu = resolveComponent("ElDropdownMenu");
-  const _component_ElDropdown = resolveComponent("ElDropdown");
-  return openBlock(), createBlock(_component_ElDropdown, {
+  const _component_EleDropdown = resolveComponent("EleDropdown");
+  return openBlock(), createBlock(_component_EleDropdown, mergeProps(!_ctx.contextMenu || typeof _ctx.contextMenu == "boolean" ? {} : _ctx.contextMenu, {
     ref: "dropdownRef",
     trigger: "contextmenu",
     placement: "bottom-start",
     disabled: !_ctx.contextMenu,
     popperClass: "ele-tab-popup",
+    popperOptions: {
+      modifiers: [{ name: "offset", options: { offset: [0, 8] } }]
+    },
+    items: _ctx.contextMenus,
     onCommand: _ctx.onContextMenu,
     onVisibleChange: _ctx.onContextVisible
-  }, {
-    dropdown: withCtx(() => [
-      _ctx.$slots.contextMenu ? (openBlock(), createBlock(_component_ElDropdownMenu, { key: 0 }, {
-        default: withCtx(() => [
-          renderSlot(_ctx.$slots, "contextMenu", {
-            item: _ctx.item,
-            tabName: _ctx.tabName,
-            active: _ctx.active
-          })
-        ]),
-        _: 3
-      })) : createCommentVNode("", true)
-    ]),
+  }), createSlots({
     default: withCtx(() => [
       createElementVNode("div", {
         class: "ele-tab-title",
@@ -94,8 +87,20 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
         ])
       ])
     ]),
-    _: 3
-  }, 8, ["disabled", "onCommand", "onVisibleChange"]);
+    _: 2
+  }, [
+    _ctx.$slots.contextMenu ? {
+      name: "dropdownMenu",
+      fn: withCtx(() => [
+        renderSlot(_ctx.$slots, "contextMenu", {
+          item: _ctx.item,
+          tabName: _ctx.tabName,
+          active: _ctx.active
+        })
+      ]),
+      key: "0"
+    } : void 0
+  ]), 1040, ["disabled", "items", "onCommand", "onVisibleChange"]);
 }
 const tabTitle = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 export {

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

@@ -1,11 +1,13 @@
 import type { Ref } from 'vue';
-import type { TabPaneName, TabsPaneContext, TabsProps } from 'element-plus';
+import type { TabPaneName, TabsPaneContext } from 'element-plus';
 import { omit } from '../utils/core';
-import type { ElTabsInstance, ElDropdownInstance } from '../ele-app/types';
+import type { ElTabsProps, ElTabsInstance } from '../ele-app/types';
+import type { DropdownInstance } from '../ele-file-list/types';
+import type { DropdownItem } from '../ele-dropdown/types';
 import type { TabPaneItem, TabEventOption } from './types';
 import type TabTitleType from "./components/tab-title";
 export type TabTitleInstance = InstanceType<typeof TabTitleType>;
-declare const _sfc_main: import("vue").DefineComponent<{
+declare const _default: import("vue").DefineComponent<{
     items: {
         type: import("vue").PropType<TabPaneItem[]>;
         required: boolean;
@@ -13,7 +15,8 @@ declare const _sfc_main: import("vue").DefineComponent<{
     size: import("vue").PropType<import("./types").TabSize>;
     type: import("vue").PropType<import("./types").TabType>;
     center: BooleanConstructor;
-    contextMenu: BooleanConstructor;
+    contextMenu: import("vue").PropType<boolean | import("../ele-file-list/types").EleDropdownProps>;
+    contextMenus: import("vue").PropType<import("./types").ContextMenus>;
     sortable: BooleanConstructor;
     mousewheel: BooleanConstructor;
     handleClick: BooleanConstructor;
@@ -46,8 +49,141 @@ declare const _sfc_main: import("vue").DefineComponent<{
 }, {
     omit: typeof omit;
     tabRef: Ref<ElTabsInstance>;
-    itemRefs: Ref<any[]>;
-    tabProps: import("vue").ComputedRef<Partial<Omit<TabsProps, "type">>>;
+    itemRefs: Ref<({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            handleClick?: boolean | undefined;
+            key?: string | number | symbol | undefined;
+            readonly label?: string | undefined;
+            style?: unknown;
+            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;
+            readonly item?: TabPaneItem | undefined;
+            readonly contextMenu?: boolean | import("../ele-file-list/types").EleDropdownProps | undefined;
+            onItemClick?: ((_opt: TabEventOption) => any) | undefined;
+            onContextMenu?: ((_option: TabEventOption) => any) | undefined;
+            onContextOpen?: ((_ref: DropdownInstance) => any) | undefined;
+            readonly active?: string | number | undefined;
+            readonly tabName?: string | number | undefined;
+            readonly contextMenus?: DropdownItem[] | 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: "itemClick", _opt: TabEventOption) => void) & ((event: "contextMenu", _option: TabEventOption) => void) & ((event: "contextOpen", _ref: DropdownInstance) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            active: (StringConstructor | NumberConstructor)[];
+            tabName: (StringConstructor | NumberConstructor)[];
+            label: StringConstructor;
+            item: import("vue").PropType<TabPaneItem>;
+            contextMenu: import("vue").PropType<boolean | import("../ele-file-list/types").EleDropdownProps>;
+            contextMenus: import("vue").PropType<DropdownItem[]>;
+            handleClick: BooleanConstructor;
+        }>> & {
+            onItemClick?: ((_opt: TabEventOption) => any) | undefined;
+            onContextMenu?: ((_option: TabEventOption) => any) | undefined;
+            onContextOpen?: ((_ref: DropdownInstance) => any) | undefined;
+        }, {
+            dropdownRef: Ref<DropdownInstance>;
+            onContextMenu: (command: string) => void;
+            onContextVisible: (visible: boolean) => void;
+            onClick: (e: MouseEvent) => void;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            itemClick: (_opt: TabEventOption) => true;
+            contextMenu: (_option: TabEventOption) => true;
+            contextOpen: (_ref: DropdownInstance) => true;
+        }, string, {
+            handleClick: boolean;
+        }, {}, 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<{
+        active: (StringConstructor | NumberConstructor)[];
+        tabName: (StringConstructor | NumberConstructor)[];
+        label: StringConstructor;
+        item: import("vue").PropType<TabPaneItem>;
+        contextMenu: import("vue").PropType<boolean | import("../ele-file-list/types").EleDropdownProps>;
+        contextMenus: import("vue").PropType<DropdownItem[]>;
+        handleClick: BooleanConstructor;
+    }>> & {
+        onItemClick?: ((_opt: TabEventOption) => any) | undefined;
+        onContextMenu?: ((_option: TabEventOption) => any) | undefined;
+        onContextOpen?: ((_ref: DropdownInstance) => any) | undefined;
+    } & import("vue").ShallowUnwrapRef<{
+        dropdownRef: Ref<DropdownInstance>;
+        onContextMenu: (command: string) => void;
+        onContextVisible: (visible: boolean) => void;
+        onClick: (e: MouseEvent) => void;
+    }> & {} & import("vue").ComponentCustomProperties & {})[]>;
+    tabProps: import("vue").ComputedRef<Omit<ElTabsProps, "type">>;
+    getContextMenus: (item: TabPaneItem) => DropdownItem[] | undefined;
     onUpdateModelValue: (name: TabPaneName) => void;
     onTabClick: (pane: TabsPaneContext, e: Event) => void;
     onTabChange: (name: TabPaneName) => void;
@@ -56,14 +192,14 @@ declare const _sfc_main: import("vue").DefineComponent<{
     onEdit: (name: TabPaneName | undefined, action: 'remove' | 'add') => void;
     onItemClick: (option: TabEventOption) => void;
     onItemContextMenu: (option: TabEventOption) => void;
-    onItemContextOpen: (ref: ElDropdownInstance) => void;
+    onItemContextOpen: (ref: DropdownInstance) => void;
     onContextmenu: (e: MouseEvent) => void;
     hideAllDropdown: () => void;
     updateActiveBar: () => void;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     tabItemClick: (_opt: TabEventOption) => boolean;
     tabContextMenu: (_opt: TabEventOption) => boolean;
-    tabContextOpen: (_ref: ElDropdownInstance) => boolean;
+    tabContextOpen: (_ref: DropdownInstance) => boolean;
     tabSortChange: (_data: TabPaneItem[]) => boolean;
     "update:modelValue": (name: TabPaneName) => boolean;
     tabClick: (pane: {
@@ -72,9 +208,9 @@ declare const _sfc_main: import("vue").DefineComponent<{
             [name: string]: import("vue").Slot<any> | undefined;
         }>;
         props: {
+            readonly disabled: boolean;
             readonly label: string;
             readonly closable: boolean;
-            readonly disabled: boolean;
             readonly lazy: boolean;
             readonly name?: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown> | undefined;
         };
@@ -84,7 +220,7 @@ declare const _sfc_main: import("vue").DefineComponent<{
         isClosable: boolean;
     }, ev: Event) => boolean;
     tabChange: (name: TabPaneName) => boolean;
-    edit: (paneName: TabPaneName | undefined, action: "remove" | "add") => boolean;
+    edit: (paneName: TabPaneName | undefined, action: "add" | "remove") => boolean;
     tabRemove: (name: TabPaneName) => boolean;
     tabAdd: () => boolean;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
@@ -95,7 +231,8 @@ declare const _sfc_main: import("vue").DefineComponent<{
     size: import("vue").PropType<import("./types").TabSize>;
     type: import("vue").PropType<import("./types").TabType>;
     center: BooleanConstructor;
-    contextMenu: BooleanConstructor;
+    contextMenu: import("vue").PropType<boolean | import("../ele-file-list/types").EleDropdownProps>;
+    contextMenus: import("vue").PropType<import("./types").ContextMenus>;
     sortable: BooleanConstructor;
     mousewheel: BooleanConstructor;
     handleClick: BooleanConstructor;
@@ -126,20 +263,20 @@ declare const _sfc_main: import("vue").DefineComponent<{
     })[], unknown, unknown, () => true, boolean>;
     stretch: BooleanConstructor;
 }>> & {
+    "onUpdate:modelValue"?: ((name: TabPaneName) => any) | undefined;
     onTabItemClick?: ((_opt: TabEventOption) => any) | undefined;
     onTabContextMenu?: ((_opt: TabEventOption) => any) | undefined;
-    onTabContextOpen?: ((_ref: ElDropdownInstance) => any) | undefined;
+    onTabContextOpen?: ((_ref: DropdownInstance) => any) | undefined;
     onTabSortChange?: ((_data: TabPaneItem[]) => any) | undefined;
-    "onUpdate:modelValue"?: ((name: TabPaneName) => any) | undefined;
     onTabClick?: ((pane: {
         uid: number;
         slots: Readonly<{
             [name: string]: import("vue").Slot<any> | undefined;
         }>;
         props: {
+            readonly disabled: boolean;
             readonly label: string;
             readonly closable: boolean;
-            readonly disabled: boolean;
             readonly lazy: boolean;
             readonly name?: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown> | undefined;
         };
@@ -149,20 +286,19 @@ declare const _sfc_main: import("vue").DefineComponent<{
         isClosable: boolean;
     }, ev: Event) => any) | undefined;
     onTabChange?: ((name: TabPaneName) => any) | undefined;
-    onEdit?: ((paneName: TabPaneName | undefined, action: "remove" | "add") => any) | undefined;
+    onEdit?: ((paneName: TabPaneName | undefined, action: "add" | "remove") => any) | undefined;
     onTabRemove?: ((name: TabPaneName) => any) | undefined;
     onTabAdd?: (() => any) | undefined;
 }, {
-    closable: boolean;
     center: boolean;
-    contextMenu: boolean;
-    sortable: boolean;
-    mousewheel: boolean;
-    handleClick: boolean;
+    closable: boolean;
     addable: boolean;
     editable: boolean;
     tabPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "bottom" | "right" | "left", unknown>;
     beforeLeave: (newName: TabPaneName, oldName: TabPaneName) => import("element-plus/es/utils").Awaitable<boolean | void>;
     stretch: boolean;
+    sortable: boolean;
+    handleClick: boolean;
+    mousewheel: boolean;
 }, {}>;
-export default _sfc_main;
+export default _default;

package/es/ele-tabs/index.js

@@ -1,6 +1,7 @@
 import { defineComponent, ref, computed, onMounted, onBeforeUnmount, watch, resolveComponent, openBlock, createBlock, mergeProps, withCtx, createElementBlock, Fragment, renderList, createSlots, createVNode, renderSlot, normalizeProps, guardReactiveProps } from "vue";
-import { ElTabs, ElTabPane } from "element-plus";
 import SortableJs from "sortablejs";
+import { ElTabs, ElTabPane } from "element-plus";
+import { useLicense } from "../ele-config-provider/receiver";
 import { pick, omit } from "../utils/core";
 import TabTitle from "./components/tab-title";
 import { tabsProps, tabsEmits, tabPropKeys } from "./props";
@@ -10,12 +11,22 @@ const _sfc_main = defineComponent({
   props: tabsProps,
   emits: tabsEmits,
   setup(props, { emit }) {
+    const { authenticated } = useLicense();
     const current = { sortIns: null, isScroll: false };
     const tabRef = ref(null);
     const itemRefs = ref([]);
     const tabProps = computed(() => {
       return pick(props, tabPropKeys);
     });
+    const getContextMenus = (item) => {
+      if (!authenticated.value) {
+        return [];
+      }
+      if (typeof props.contextMenus === "function") {
+        return props.contextMenus(item);
+      }
+      return props.contextMenus;
+    };
     const onUpdateModelValue = (name) => {
       emit("update:modelValue", name);
     };
@@ -71,7 +82,7 @@ const _sfc_main = defineComponent({
     const bindDragSort = () => {
       unbindDragSort();
       const el = getNavEl();
-      if (!props.sortable || !el) {
+      if (!authenticated.value || !props.sortable || !el) {
         return;
       }
       current.sortIns = new SortableJs(el, {
@@ -167,6 +178,7 @@ const _sfc_main = defineComponent({
       tabRef,
       itemRefs,
       tabProps,
+      getContextMenus,
       onUpdateModelValue,
       onTabClick,
       onTabChange,
@@ -193,7 +205,8 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_TabTitle = resolveComponent("TabTitle");
   const _component_ElTabPane = resolveComponent("ElTabPane");
   const _component_ElTabs = resolveComponent("ElTabs");
-  return openBlock(), createBlock(_component_ElTabs, mergeProps({ ref: "tabRef" }, _ctx.tabProps, {
+  return openBlock(), createBlock(_component_ElTabs, mergeProps(_ctx.tabProps, {
+    ref: "tabRef",
     type: _ctx.type === "card" || _ctx.type === "border-card" ? _ctx.type : void 0,
     class: [
       "ele-tabs",
@@ -229,6 +242,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
               active: _ctx.modelValue,
               handleClick: _ctx.handleClick,
               contextMenu: _ctx.contextMenu,
+              contextMenus: _ctx.getContextMenus(item),
               onContextMenu: _ctx.onItemContextMenu,
               onContextOpen: _ctx.onItemContextOpen,
               onItemClick: _ctx.onItemClick
@@ -247,7 +261,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
                 ]),
                 key: "1"
               } : void 0
-            ]), 1032, ["item", "label", "tabName", "active", "handleClick", "contextMenu", "onContextMenu", "onContextOpen", "onItemClick"])
+            ]), 1032, ["item", "label", "tabName", "active", "handleClick", "contextMenu", "contextMenus", "onContextMenu", "onContextOpen", "onItemClick"])
           ]),
           _: 2
         }, [

package/es/ele-tabs/props.d.ts

@@ -1,7 +1,7 @@
 import type { PropType, ExtractPropTypes } from 'vue';
 import { tabsProps as elTabsProps } from 'element-plus';
-import type { ElDropdownInstance } from '../ele-app/types';
-import type { TabPaneItem, TabSize, TabType, TabEventOption } from './types';
+import type { EleDropdownProps, DropdownInstance } from '../ele-file-list/types';
+import type { TabPaneItem, TabSize, TabType, TabEventOption, ContextMenus } from './types';
 /**
  * 属性
  */
@@ -13,7 +13,8 @@ export declare const tabsProps: {
     size: PropType<TabSize>;
     type: PropType<TabType>;
     center: BooleanConstructor;
-    contextMenu: BooleanConstructor;
+    contextMenu: PropType<boolean | EleDropdownProps>;
+    contextMenus: PropType<ContextMenus>;
     sortable: BooleanConstructor;
     mousewheel: BooleanConstructor;
     handleClick: BooleanConstructor;
@@ -51,7 +52,7 @@ export type TabsProps = ExtractPropTypes<typeof tabsProps>;
 export declare const tabsEmits: {
     tabItemClick: (_opt: TabEventOption) => boolean;
     tabContextMenu: (_opt: TabEventOption) => boolean;
-    tabContextOpen: (_ref: ElDropdownInstance) => boolean;
+    tabContextOpen: (_ref: DropdownInstance) => boolean;
     tabSortChange: (_data: TabPaneItem[]) => boolean;
     "update:modelValue": (name: import("element-plus").TabPaneName) => boolean;
     tabClick: (pane: {
@@ -60,9 +61,9 @@ export declare const tabsEmits: {
             [name: string]: import("vue").Slot<any> | undefined;
         }>;
         props: {
+            readonly disabled: boolean;
             readonly label: string;
             readonly closable: boolean;
-            readonly disabled: boolean;
             readonly lazy: boolean;
             readonly name?: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown> | undefined;
         };

package/es/ele-tabs/props.js

@@ -13,7 +13,9 @@ const tabsProps = {
   // 标签是否居中显示
   center: Boolean,
   // 是否支持右键菜单
-  contextMenu: Boolean,
+  contextMenu: [Boolean, Object],
+  // 右键菜单
+  contextMenus: [Array, Function],
   // 是否支持拖动排序
   sortable: Boolean,
   // 是否支持鼠标滚轮滑动

package/es/ele-tabs/style/css-var.scss

@@ -1,33 +1,33 @@
-@use '../../style/themes/default.scss' as *;
+@use '../../style/util.scss' as *;
 
 @mixin set-tab-var($var) {
-  .ele-tabs > .el-tabs__header,
+  .ele-tabs,
   .ele-tab-tool {
     @include set-ele-var('tab', $var);
   }
 
-  .ele-tabs.is-small > .el-tabs__header,
+  .ele-tabs.is-small,
   .ele-tab-wrap.is-small .ele-tab-tool {
-    @include set-ele-var('tab-small', $var);
+    @include set-ele-var('tab-sm', $var);
   }
 
-  .ele-tabs.is-large > .el-tabs__header,
+  .ele-tabs.is-large,
   .ele-tab-wrap.is-large .ele-tab-tool {
-    @include set-ele-var('tab-large', $var);
+    @include set-ele-var('tab-lg', $var);
   }
 
-  .ele-tabs.is-simple > .el-tabs__header,
-  .ele-tabs.is-indicator > .el-tabs__header,
+  .ele-tabs.is-simple,
+  .ele-tabs.is-indicator,
   .ele-tab-wrap.is-simple .ele-tab-tool,
   .ele-tab-wrap.is-indicator .ele-tab-tool {
     @include set-ele-var('tab-simple', $var);
   }
 
-  .ele-tabs.is-indicator > .el-tabs__header {
+  .ele-tabs.is-indicator {
     @include set-ele-var('tab-indicator', $var);
   }
 
-  .ele-tabs.is-button > .el-tabs__header,
+  .ele-tabs.is-button,
   .ele-tab-wrap.is-button .ele-tab-tool,
   .ele-admin-tab-card .ele-admin-tabs {
     @include set-ele-var('tab-button', $var);

package/es/ele-tabs/style/index.js

@@ -1,5 +1,4 @@
 import 'element-plus/es/components/tabs/style/index';
 import 'element-plus/es/components/tab-pane/style/index';
-import 'element-plus/es/components/dropdown/style/index';
-import 'element-plus/es/components/dropdown-menu/style/index';
+import '../../ele-dropdown/style/index';
 import './index.scss';