ele-admin-plus 1.0.2 → 1.1.0

package/lib/ele-tooltip/index.js

@@ -0,0 +1,166 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const receiver = require("../ele-config-provider/receiver");
+const core = require("../utils/core");
+const props = require("./props");
+const _sfc_main = vue.defineComponent({
+  name: "EleTooltip",
+  components: { ElTooltip: elementPlus.ElTooltip },
+  props: props.tooltipProps,
+  emits: elementPlus.tooltipEmits,
+  setup(props2, { emit }) {
+    const { authenticated } = receiver.useLicense();
+    const tooltipRef = vue.ref();
+    const rootProps = vue.computed(() => {
+      const options = core.omit(props2, [
+        "content",
+        "bodyStyle",
+        "onUpdate:visible",
+        "onBefore-show",
+        "onBefore-hide",
+        "onShow",
+        "onHide",
+        "onOpen",
+        "onClose"
+      ]);
+      if (authenticated.value) {
+        const classes = ["ele-popper", "ele-tooltip"];
+        if (typeof props2.popperClass === "string" && props2.popperClass) {
+          classes.push(props2.popperClass);
+        }
+        options.popperClass = classes.join(" ");
+      }
+      if (props2.bg || props2.arrowBg) {
+        options.effect = "dark";
+        const style = {};
+        if (props2.bg) {
+          style["--ele-tooltip-bg"] = props2.bg;
+        }
+        if (props2.arrowBg) {
+          style["--ele-tooltip-arrow-bg"] = props2.arrowBg;
+        }
+        const popStyle = props2.popperStyle;
+        if (!popStyle) {
+          options.popperStyle = style;
+        } else if (Array.isArray(popStyle)) {
+          options.popperStyle = [style, ...popStyle];
+        } else {
+          options.popperStyle = [style, popStyle];
+        }
+      }
+      return options;
+    });
+    const popperRef = vue.computed(() => {
+      var _a;
+      return (_a = tooltipRef.value) == null ? void 0 : _a.popperRef;
+    });
+    const contentRef = vue.computed(() => {
+      var _a;
+      return (_a = tooltipRef.value) == null ? void 0 : _a.contentRef;
+    });
+    const isFocusInsideContent = () => {
+      tooltipRef.value && tooltipRef.value.isFocusInsideContent();
+    };
+    const updatePopper = () => {
+      tooltipRef.value && tooltipRef.value.updatePopper();
+    };
+    const onOpen = (opt) => {
+      tooltipRef.value && tooltipRef.value.onOpen(opt);
+    };
+    const onClose = (opt) => {
+      tooltipRef.value && tooltipRef.value.onClose(opt);
+    };
+    const hide = (opt) => {
+      tooltipRef.value && tooltipRef.value.hide(opt);
+    };
+    const onUpdateVisible = (visible) => {
+      emit("update:visible", visible);
+    };
+    const onPopBeforeShow = (e) => {
+      emit("before-show", e);
+    };
+    const onPopBeforeHide = (e) => {
+      emit("before-hide", e);
+    };
+    const onPopShow = (e) => {
+      emit("show", e);
+    };
+    const onPopHide = (e) => {
+      emit("hide", e);
+    };
+    const onPopOpen = (e) => {
+      emit("open", e);
+    };
+    const onPopClose = (e) => {
+      emit("close", e);
+    };
+    vue.onDeactivated(() => {
+      if (!props2.keepAlive) {
+        hide(void 0);
+      }
+    });
+    return {
+      tooltipRef,
+      rootProps,
+      popperRef,
+      contentRef,
+      isFocusInsideContent,
+      updatePopper,
+      onOpen,
+      onClose,
+      hide,
+      onUpdateVisible,
+      onPopBeforeShow,
+      onPopBeforeHide,
+      onPopShow,
+      onPopHide,
+      onPopOpen,
+      onPopClose
+    };
+  }
+});
+const _export_sfc = (sfc, props2) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props2) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = ["innerHTML"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElTooltip = vue.resolveComponent("ElTooltip");
+  return vue.openBlock(), vue.createBlock(_component_ElTooltip, vue.mergeProps(_ctx.rootProps, {
+    ref: "tooltipRef",
+    "onUpdate:visible": _ctx.onUpdateVisible,
+    onBeforeShow: _ctx.onPopBeforeShow,
+    onBeforeHide: _ctx.onPopBeforeHide,
+    onShow: _ctx.onPopShow,
+    onHide: _ctx.onPopHide,
+    onOpen: _ctx.onPopOpen,
+    onClose: _ctx.onPopClose
+  }), {
+    content: vue.withCtx(() => [
+      _ctx.rawContent && _ctx.content != null && _ctx.content != "" ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        innerHTML: _ctx.content,
+        class: "ele-tooltip-body",
+        style: vue.normalizeStyle(_ctx.bodyStyle)
+      }, null, 12, _hoisted_1)) : (vue.openBlock(), vue.createElementBlock("div", {
+        key: 1,
+        class: "ele-tooltip-body",
+        style: vue.normalizeStyle(_ctx.bodyStyle)
+      }, [
+        vue.renderSlot(_ctx.$slots, "content", {}, () => [
+          vue.createTextVNode(vue.toDisplayString(_ctx.content), 1)
+        ])
+      ], 4))
+    ]),
+    default: vue.withCtx(() => [
+      _ctx.$slots.default ? vue.renderSlot(_ctx.$slots, "default", { key: 0 }) : vue.createCommentVNode("", true)
+    ]),
+    _: 3
+  }, 16, ["onUpdate:visible", "onBeforeShow", "onBeforeHide", "onShow", "onHide", "onOpen", "onClose"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;

package/lib/ele-tooltip/props.d.ts

@@ -0,0 +1,317 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+import type { StyleValue } from '../ele-app/types';
+/**
+ * 属性
+ */
+export declare const tooltipProps: {
+    bodyStyle: PropType<StyleValue>;
+    bg: StringConstructor;
+    arrowBg: StringConstructor;
+    keepAlive: BooleanConstructor;
+    offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    trigger: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "hover" | "focus" | "click" | "contextmenu" | import("element-plus").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").TooltipTriggerType>) | ((new (...args: any[]) => "hover" | "focus" | "click" | "contextmenu" | import("element-plus").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").TooltipTriggerType>))[], unknown, unknown, "hover", boolean>;
+    effect: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "dark", boolean>;
+    placement: import("element-plus/es/utils").EpPropFinalized<StringConstructor, import("element-plus").Placement, unknown, "bottom", boolean>;
+    popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | ((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>))[], unknown, unknown, () => {}, boolean>;
+    id: StringConstructor;
+    popperClass: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | any[] | {
+            [x: string]: boolean;
+        })[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | any[] | {
+            [x: string]: boolean;
+        })[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | any[] | {
+            [x: string]: boolean;
+        })[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | any[] | {
+            [x: string]: boolean;
+        })[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+    role: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "menu" | "group" | "listbox" | "grid" | "tooltip" | "dialog" | "navigation" | "tree", unknown, "tooltip", boolean>;
+    teleported: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    strategy: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
+    visible: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => boolean) | (() => boolean | null) | ((new (...args: any[]) => boolean) | (() => boolean | null))[], unknown, unknown, null, boolean>;
+    transition: StringConstructor;
+    content: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    popperStyle: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    enterable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    showAfter: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    hideAfter: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
+    autoClose: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    showArrow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    persistent: BooleanConstructor;
+    arrowOffset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
+    triggerKeys: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => string[], boolean>;
+    virtualRef: {
+        readonly type: PropType<import("element-plus").Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    virtualTriggering: BooleanConstructor;
+    onMouseenter: {
+        readonly type: PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onMouseleave: {
+        readonly type: PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onClick: {
+        readonly type: PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onKeydown: {
+        readonly type: PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onFocus: {
+        readonly type: PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onBlur: {
+        readonly type: PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onContextmenu: {
+        readonly type: PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    open: BooleanConstructor;
+    appendTo: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rawContent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    ariaLabel: StringConstructor;
+    className: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | any[] | {
+            [x: string]: boolean;
+        })[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | any[] | {
+            [x: string]: boolean;
+        })[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | any[] | {
+            [x: string]: boolean;
+        })[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | any[] | {
+            [x: string]: boolean;
+        })[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    pure: BooleanConstructor;
+    focusOnShow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    trapping: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    referenceEl: {
+        readonly type: PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    triggerTargetEl: {
+        readonly type: PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    stopPopperMouseEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    zIndex: NumberConstructor;
+    boundariesPadding: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    fallbackPlacements: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | ((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]))[], unknown, unknown, undefined, boolean>;
+    gpuAcceleration: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+};
+export type TooltipProps = ExtractPropTypes<typeof tooltipProps>;
+/**
+ * 事件
+ */
+export type TooltipEmits = {
+    'update:visible': (visible: boolean) => boolean;
+    'before-show': (e: Event) => boolean;
+    'before-hide': (e: Event) => boolean;
+    show: (e: Event) => boolean;
+    hide: (e: Event) => boolean;
+    open: (e: any) => boolean;
+    close: (e: any) => boolean;
+};

package/lib/ele-tooltip/props.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const elementPlus = require("element-plus");
+const core = require("../utils/core");
+const normalizeProps = core.omit(elementPlus.useTooltipProps, ["onUpdate:visible", "style"]);
+const tooltipProps = {
+  ...normalizeProps,
+  // 自定义内容样式
+  bodyStyle: Object,
+  // 自定义背景色
+  bg: String,
+  // 自定义箭头颜色
+  arrowBg: String,
+  // 是否在KeepAlive失活后继续显示
+  keepAlive: Boolean
+};
+exports.tooltipProps = tooltipProps;

package/lib/ele-tooltip/style/css-var.scss

@@ -0,0 +1,7 @@
+@use '../../style/util.scss' as *;
+
+@mixin set-tooltip-var($var) {
+  .ele-tooltip.is-light {
+    @include set-ele-var('tooltip-light', $var);
+  }
+}

package/lib/ele-tooltip/style/index.js

@@ -0,0 +1,4 @@
+"use strict";
+require("element-plus/es/components/tooltip/style/index");
+require("../../ele-popover/style/index");
+require("./index.scss");

package/lib/ele-tooltip/style/index.scss

@@ -0,0 +1,66 @@
+@use '../../style/themes/default.scss' as *;
+@use '../../style/util.scss' as *;
+@use './css-var.scss' as *;
+
+@include set-tooltip-var($ele);
+
+.ele-tooltip-body {
+  background: inherit;
+  border-radius: inherit;
+  padding: eleVar('tooltip', 'padding');
+  box-sizing: border-box;
+  position: relative;
+  z-index: 2;
+}
+
+.ele-popper.el-popper.ele-tooltip {
+  color: eleVar('tooltip', 'color');
+  font-size: eleVar('tooltip', 'font-size');
+  line-height: eleVar('tooltip', 'line-height');
+  padding: 0;
+  background: eleVar('tooltip', 'bg');
+  border: eleVar('tooltip', 'border');
+  box-shadow: eleVar('tooltip', 'shadow');
+  border-radius: eleVar('tooltip', 'radius');
+
+  & > .el-popper__arrow::before {
+    background: eleVar('tooltip', 'arrow-bg');
+    border: eleVar('tooltip', 'border');
+    box-shadow: eleVar('tooltip', 'arrow-shadow');
+  }
+
+  &.is-dark {
+    padding: 0;
+  }
+
+  &.is-light {
+    color: eleVar('tooltip-light', 'color');
+    background: eleVar('tooltip-light', 'bg');
+    border: eleVar('tooltip-light', 'border');
+    box-shadow: eleVar('tooltip-light', 'shadow');
+
+    & > .el-popper__arrow::before {
+      background: eleVar('tooltip-light', 'arrow-bg');
+      border: eleVar('tooltip-light', 'border');
+      box-shadow: eleVar('tooltip-light', 'arrow-shadow');
+    }
+  }
+
+  &.is-danger,
+  &.is-danger > .el-popper__arrow::before {
+    background: elVar('color-danger');
+    border-color: elVar('color-danger');
+  }
+
+  &.is-warning,
+  &.is-warning > .el-popper__arrow::before {
+    background: elVar('color-warning');
+    border-color: elVar('color-warning');
+  }
+
+  &.is-success,
+  &.is-success > .el-popper__arrow::before {
+    background: elVar('color-success');
+    border-color: elVar('color-success');
+  }
+}

package/lib/ele-tour/index.d.ts

@@ -1,7 +1,8 @@
 import type { Ref } from 'vue';
-import type { ElPopoverInstance, StyleValue } from '../ele-app/types';
+import type { StyleValue } from '../ele-app/types';
+import type { ElePopoverProps } from '../ele-avatar-group/types';
 import type { TourStep, TourLocale } from './types';
-declare const _sfc_main: import("vue").DefineComponent<{
+declare const _default: import("vue").DefineComponent<{
     modelValue: NumberConstructor;
     steps: {
         type: import("vue").PropType<TourStep[]>;
@@ -21,13 +22,13 @@ declare const _sfc_main: import("vue").DefineComponent<{
     lang: import("vue").ComputedRef<TourLocale>;
     rootRef: Ref<HTMLDivElement | null>;
     triggerRef: Ref<HTMLDivElement | null>;
-    popoverRef: Ref<ElPopoverInstance>;
+    popoverRef: any;
     visible: Ref<boolean>;
     step: import("vue").ShallowRef<TourStep | null>;
     isLast: Ref<boolean>;
     boxStyle: Ref<StyleValue>;
     showMask: Ref<boolean>;
-    popProps: import("vue").ShallowRef<Partial<import("element-plus").PopoverProps>>;
+    popProps: import("vue").ShallowRef<ElePopoverProps>;
     rootStyle: import("vue").ComputedRef<StyleValue>;
     onPrev: () => void;
     onNext: () => void;
@@ -56,4 +57,4 @@ declare const _sfc_main: import("vue").DefineComponent<{
     mask: boolean;
     padding: number;
 }, {}>;
-export default _sfc_main;
+export default _default;

package/lib/ele-tour/index.js

@@ -1,12 +1,13 @@
 "use strict";
 const vue = require("vue");
 const elementPlus = require("element-plus");
+const ElePopover = require("../ele-popover/index");
 const receiver = require("../ele-config-provider/receiver");
 const util = require("./util");
 const props = require("./props");
 const _sfc_main = vue.defineComponent({
   name: "EleTour",
-  components: { ElPopover: elementPlus.ElPopover, ElButton: elementPlus.ElButton },
+  components: { ElButton: elementPlus.ElButton, ElePopover },
   props: props.tourProps,
   emits: props.tourEmits,
   setup(props2, { emit }) {
@@ -137,7 +138,7 @@ const _hoisted_4 = { class: "ele-tour-counter" };
 const _hoisted_5 = { class: "ele-tour-action" };
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_ElButton = vue.resolveComponent("ElButton");
-  const _component_ElPopover = vue.resolveComponent("ElPopover");
+  const _component_ElePopover = vue.resolveComponent("ElePopover");
   return vue.openBlock(), vue.createBlock(vue.Teleport, { to: "body" }, [
     vue.createElementVNode("div", {
       ref: "rootRef",
@@ -153,7 +154,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
         class: "ele-tour-reference",
         style: vue.normalizeStyle(_ctx.boxStyle)
       }, null, 4),
-      vue.createVNode(_component_ElPopover, vue.mergeProps(_ctx.popProps, {
+      vue.createVNode(_component_ElePopover, vue.mergeProps(_ctx.popProps, {
         ref: "popoverRef",
         virtualRef: _ctx.triggerRef,
         virtualTriggering: true,

package/lib/ele-tour/style/index.js

@@ -1,4 +1,4 @@
 "use strict";
-require("element-plus/es/components/popover/style/index");
 require("element-plus/es/components/button/style/index");
+require("../../ele-popover/style/index");
 require("./index.scss");