ep-craft 0.1.20 → 0.1.21

package/dist/components/tooltip/src/content.vue.d.ts

@@ -0,0 +1,47 @@
+import type { ElTooltipContentProps } from './content';
+import type { PopperContentInstance } from '@element-plus/components/popper';
+declare var __VLS_29: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_29) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ElTooltipContentProps, {
+    /**
+     * @description el-popper-content component instance
+     */
+    contentRef: import("vue").Ref<PopperContentInstance | undefined, PopperContentInstance | undefined>;
+    /**
+     * @description validate current focus event is trigger inside el-popper-content
+     */
+    isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ElTooltipContentProps> & Readonly<{}>, {
+    offset: number;
+    teleported: boolean;
+    style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+    effect: import("@element-plus/components/popper").PopperEffect;
+    content: string;
+    visible: boolean | null;
+    enterable: boolean;
+    pure: boolean;
+    focusOnShow: boolean;
+    trapping: boolean;
+    popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+    stopPopperMouseEvent: boolean;
+    virtualTriggering: boolean;
+    loop: boolean;
+    boundariesPadding: number;
+    gpuAcceleration: boolean;
+    placement: import("element-plus").Placement;
+    popperOptions: Partial<import("element-plus").Options>;
+    strategy: "fixed" | "absolute";
+    arrowOffset: number;
+    showAfter: number;
+    hideAfter: number;
+    autoClose: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/tooltip/src/content.vue.js

@@ -0,0 +1,188 @@
+import { defineComponent as Y, ref as E, inject as q, computed as l, onBeforeUnmount as G, unref as o, watch as H, openBlock as h, createBlock as B, Teleport as Q, Transition as X, withCtx as S, withDirectives as Z, createVNode as _, mergeProps as ee, renderSlot as te, vShow as oe, createCommentVNode as ne, mergeDefaults as re } from "vue";
+import { onClickOutside as ae } from "../../../node_modules/.pnpm/@vueuse_core@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js";
+import { useNamespace as le } from "../../../hooks/use-namespace/index.js";
+import { castArray as se } from "../../../utils/arrays.js";
+import { focusElement as ie } from "../../../utils/dom/aria.js";
+import { composeEventHandlers as w } from "../../../utils/dom/event.js";
+import "../../../hooks/use-size/index.js";
+import { usePopperContainerId as pe } from "../../../hooks/use-popper-container/index.js";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import "../../popper/index.js";
+import { TOOLTIP_INJECTION_KEY as ce } from "./constants.js";
+import { isTriggerType as O } from "./utils.js";
+import { useTooltipContentPropsDefaults as fe } from "./content.js";
+import { computedEager as ue } from "../../../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+import de from "../../popper/src/content2.vue.js";
+const Le = /* @__PURE__ */ Y({
+  name: "ElTooltipContent",
+  inheritAttrs: !1,
+  __name: "content",
+  props: /* @__PURE__ */ re({
+    appendTo: {},
+    content: {},
+    rawContent: { type: Boolean },
+    persistent: { type: Boolean },
+    visible: { type: [Boolean, null] },
+    transition: {},
+    teleported: { type: Boolean },
+    disabled: { type: Boolean },
+    ariaLabel: {},
+    showAfter: {},
+    hideAfter: {},
+    autoClose: {},
+    id: {},
+    style: { type: [Boolean, null, String, Object, Array] },
+    className: {},
+    effect: {},
+    enterable: { type: Boolean },
+    pure: { type: Boolean },
+    focusOnShow: { type: Boolean },
+    trapping: { type: Boolean },
+    popperClass: {},
+    popperStyle: { type: [Boolean, null, String, Object, Array] },
+    referenceEl: {},
+    triggerTargetEl: {},
+    stopPopperMouseEvent: { type: Boolean },
+    virtualTriggering: { type: Boolean },
+    zIndex: {},
+    loop: { type: Boolean },
+    boundariesPadding: {},
+    fallbackPlacements: {},
+    gpuAcceleration: { type: Boolean },
+    offset: {},
+    placement: {},
+    popperOptions: {},
+    strategy: {},
+    arrowOffset: {}
+  }, fe),
+  setup(e, { expose: A }) {
+    const r = e, { selector: P } = pe(), I = le("tooltip"), s = E(), N = ue(() => {
+      var t;
+      return (t = s.value) == null ? void 0 : t.popperContentRef;
+    });
+    let a;
+    const {
+      controlled: g,
+      id: k,
+      open: f,
+      trigger: u,
+      onClose: i,
+      onOpen: R,
+      onShow: L,
+      onHide: x,
+      onBeforeShow: d,
+      onBeforeHide: m
+    } = q(ce, void 0), M = l(() => r.transition || `${I.namespace.value}-fade-in-linear`), v = l(() => process.env.NODE_ENV === "test" && !process.env.RUN_TEST_WITH_PERSISTENT ? !0 : r.persistent);
+    G(() => {
+      a == null || a();
+    });
+    const z = l(() => o(v) ? !0 : o(f)), y = l(() => r.disabled ? !1 : o(f)), D = l(() => r.appendTo || P.value), $ = l(() => r.style ?? {}), p = E(!0), j = () => {
+      x(), C() && ie(document.body, { preventScroll: !0 }), p.value = !0;
+    }, b = () => {
+      if (o(g)) return !0;
+    }, V = w(b, () => {
+      r.enterable && O(o(u), "hover") && R();
+    }), U = w(b, () => {
+      O(o(u), "hover") && i();
+    }), W = () => {
+      var t, n;
+      (n = (t = s.value) == null ? void 0 : t.updatePopper) == null || n.call(t), d == null || d();
+    }, F = () => {
+      m == null || m();
+    }, J = () => {
+      L();
+    }, K = () => {
+      r.virtualTriggering || i();
+    }, C = (t) => {
+      var T;
+      const n = (T = s.value) == null ? void 0 : T.popperContentRef, c = (t == null ? void 0 : t.relatedTarget) || document.activeElement;
+      return n == null ? void 0 : n.contains(c);
+    };
+    return H(
+      () => o(f),
+      (t) => {
+        t ? (p.value = !1, a = ae(
+          N,
+          () => {
+            if (o(g)) return;
+            se(o(u)).every((c) => c !== "hover" && c !== "focus") && i();
+          },
+          { detectIframe: !0 }
+        )) : a == null || a();
+      },
+      {
+        flush: "post"
+      }
+    ), A({
+      /**
+       * @description el-popper-content component instance
+       */
+      contentRef: s,
+      /**
+       * @description validate current focus event is trigger inside el-popper-content
+       */
+      isFocusInsideContent: C
+    }), (t, n) => (h(), B(Q, {
+      disabled: !e.teleported,
+      to: D.value
+    }, [
+      z.value || !p.value ? (h(), B(X, {
+        key: 0,
+        name: M.value,
+        appear: !v.value,
+        onAfterLeave: j,
+        onBeforeEnter: W,
+        onAfterEnter: J,
+        onBeforeLeave: F
+      }, {
+        default: S(() => [
+          Z(_(o(de), ee({
+            id: o(k),
+            ref_key: "contentRef",
+            ref: s
+          }, t.$attrs, {
+            "aria-label": e.ariaLabel,
+            "aria-hidden": p.value,
+            "boundaries-padding": e.boundariesPadding,
+            "fallback-placements": e.fallbackPlacements,
+            "gpu-acceleration": e.gpuAcceleration,
+            offset: e.offset,
+            placement: e.placement,
+            "popper-options": e.popperOptions,
+            "arrow-offset": e.arrowOffset,
+            strategy: e.strategy,
+            effect: e.effect,
+            enterable: e.enterable,
+            pure: e.pure,
+            "popper-class": e.popperClass,
+            "popper-style": [e.popperStyle, $.value],
+            "reference-el": e.referenceEl,
+            "trigger-target-el": e.triggerTargetEl,
+            visible: y.value,
+            "z-index": e.zIndex,
+            loop: e.loop,
+            onMouseenter: o(V),
+            onMouseleave: o(U),
+            onBlur: K,
+            onClose: o(i)
+          }), {
+            default: S(() => [
+              te(t.$slots, "default")
+            ]),
+            _: 3
+          }, 16, ["id", "aria-label", "aria-hidden", "boundaries-padding", "fallback-placements", "gpu-acceleration", "offset", "placement", "popper-options", "arrow-offset", "strategy", "effect", "enterable", "pure", "popper-class", "popper-style", "reference-el", "trigger-target-el", "visible", "z-index", "loop", "onMouseenter", "onMouseleave", "onClose"]), [
+            [oe, y.value]
+          ])
+        ]),
+        _: 3
+      }, 8, ["name", "appear"])) : ne("", !0)
+    ], 8, ["disabled", "to"]));
+  }
+});
+export {
+  Le as default
+};

package/dist/components/tooltip/src/content2.vue.js

@@ -0,0 +1,4 @@
+import f from "./content.vue.js";
+export {
+  f as default
+};

package/dist/components/tooltip/src/tooltip.d.ts

@@ -0,0 +1,346 @@
+import type { PopperArrowProps, PopperProps } from '@element-plus/components/popper';
+import type { ElTooltipContentProps } from './content';
+import type { UseTooltipTriggerProps } from './trigger';
+import type Tooltip from './tooltip.vue';
+import type { ExtractPublicPropTypes } from 'vue';
+export declare const useTooltipModelToggleProps: import("@element-plus/hooks").UseModelTogglePropsRaw<"visible">, useTooltipModelToggleEmits: "update:visible"[], useTooltipModelToggle: ({ indicator, toggleReason, shouldHideWhenRouteChanges, shouldProceed, onShow, onHide, }: import("@element-plus/hooks").ModelToggleParams) => {
+    hide: (event?: Event) => void;
+    show: (event?: Event) => void;
+    toggle: () => void;
+    hasUpdateHandler: import("vue").ComputedRef<boolean>;
+};
+export interface UseTooltipProps extends PopperProps, ElTooltipContentProps, UseTooltipTriggerProps, PopperArrowProps {
+    /**
+     * @description whether the tooltip content has an arrow
+     */
+    showArrow?: boolean;
+    'onUpdate:visible'?: (value: boolean) => void;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `UseTooltipProps` instead.
+ */
+export declare const useTooltipProps: {
+    showArrow: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    arrowOffset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
+    disabled: BooleanConstructor;
+    trigger: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "click" | "contextmenu" | "focus" | "hover" | import("./trigger").TooltipTriggerType[]) | (() => import("@element-plus/utils").Arrayable<import("./trigger").TooltipTriggerType>) | (((new (...args: any[]) => "click" | "contextmenu" | "focus" | "hover" | import("./trigger").TooltipTriggerType[]) | (() => import("@element-plus/utils").Arrayable<import("./trigger").TooltipTriggerType>)) | null)[], unknown, unknown, "hover", boolean>;
+    triggerKeys: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | (((new (...args: any[]) => string[]) | (() => string[])) | null)[], unknown, unknown, () => string[], boolean>;
+    focusOnTarget: BooleanConstructor;
+    virtualRef: {
+        readonly type: import("vue").PropType<import("@element-plus/components/popper").Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    virtualTriggering: BooleanConstructor;
+    onMouseenter: {
+        readonly type: import("vue").PropType<(e: MouseEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onMouseleave: {
+        readonly type: import("vue").PropType<(e: MouseEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onClick: {
+        readonly type: import("vue").PropType<(e: PointerEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onKeydown: {
+        readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onFocus: {
+        readonly type: import("vue").PropType<(e: FocusEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onBlur: {
+        readonly type: import("vue").PropType<(e: FocusEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onContextmenu: {
+        readonly type: import("vue").PropType<(e: PointerEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    id: StringConstructor;
+    open: BooleanConstructor;
+    ariaLabel: StringConstructor;
+    appendTo: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    content: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    rawContent: BooleanConstructor;
+    persistent: BooleanConstructor;
+    visible: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => boolean) | (() => boolean | null) | (((new (...args: any[]) => boolean) | (() => boolean | null)) | null)[], unknown, unknown, null, boolean>;
+    transition: StringConstructor;
+    teleported: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    loop: BooleanConstructor;
+    style: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    className: {
+        readonly type: import("vue").PropType<import("@element-plus/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 | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ 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 | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (((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 | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ 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 | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    effect: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string) | (() => import("@element-plus/components/popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("@element-plus/components/popper").PopperEffect)) | null)[], unknown, unknown, "dark", boolean>;
+    enterable: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    pure: BooleanConstructor;
+    focusOnShow: BooleanConstructor;
+    trapping: BooleanConstructor;
+    popperClass: {
+        readonly type: import("vue").PropType<import("@element-plus/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 | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ 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 | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (((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 | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ 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 | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    popperStyle: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    referenceEl: {
+        readonly type: import("vue").PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    triggerTargetEl: {
+        readonly type: import("vue").PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    stopPopperMouseEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    zIndex: NumberConstructor;
+    boundariesPadding: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    fallbackPlacements: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | (((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[])) | null)[], unknown, unknown, undefined, boolean>;
+    gpuAcceleration: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    placement: import("@element-plus/utils").EpPropFinalized<StringConstructor, import("element-plus").Placement, unknown, "bottom", boolean>;
+    popperOptions: import("@element-plus/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>)) | null)[], unknown, unknown, () => {}, boolean>;
+    strategy: import("@element-plus/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
+    showAfter: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    hideAfter: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
+    autoClose: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    "onUpdate:visible": {
+        readonly type: import("vue").PropType<(val: boolean) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    role: import("@element-plus/utils").EpPropFinalized<StringConstructor, "dialog" | "menu" | "listbox" | "grid" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
+};
+export declare const tooltipEmits: readonly [..."update:visible"[], "before-show", "before-hide", "show", "hide", "open", "close"];
+/**
+ * @deprecated Removed after 3.0.0, Use `UseTooltipProps` instead.
+ */
+export type ElTooltipProps = UseTooltipProps;
+/**
+ * @deprecated Removed after 3.0.0, Use `UseTooltipProps` instead.
+ */
+export type ElTooltipPropsPublic = ExtractPublicPropTypes<typeof useTooltipProps>;
+export type TooltipInstance = InstanceType<typeof Tooltip> & unknown;

package/dist/components/tooltip/src/tooltip.js

@@ -0,0 +1,47 @@
+import { buildProps as o } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import "../../../hooks/use-size/index.js";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import { createModelToggleComposable as e } from "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import "../../popper/index.js";
+import { useTooltipContentProps as r } from "./content.js";
+import { useTooltipTriggerProps as p } from "./trigger.js";
+import { popperArrowProps as t } from "../../popper/src/arrow.js";
+import { popperProps as i } from "../../popper/src/popper.js";
+const {
+  useModelToggleProps: l,
+  useModelToggleEmits: s,
+  useModelToggle: c
+} = e("visible");
+o({
+  ...i,
+  ...l,
+  ...r,
+  ...p,
+  ...t,
+  /**
+   * @description whether the tooltip content has an arrow
+   */
+  showArrow: {
+    type: Boolean,
+    default: !0
+  }
+});
+const E = [
+  ...s,
+  "before-show",
+  "before-hide",
+  "show",
+  "hide",
+  "open",
+  "close"
+];
+export {
+  E as tooltipEmits,
+  c as useTooltipModelToggle,
+  s as useTooltipModelToggleEmits,
+  l as useTooltipModelToggleProps
+};