ep-craft 0.1.19 → 0.1.21

package/dist/components/popper/src/utils.js

@@ -0,0 +1,57 @@
+import { unrefElement as f } 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 "vue";
+import { isClient as s } from "../../../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+const u = (e, t = []) => {
+  const { placement: n, strategy: i, popperOptions: o } = e, r = {
+    placement: n,
+    strategy: i,
+    ...o,
+    modifiers: [...m(e), ...t]
+  };
+  return a(r, o == null ? void 0 : o.modifiers), r;
+}, d = (e) => {
+  if (s)
+    return f(e);
+};
+function m(e) {
+  const { offset: t, gpuAcceleration: n, fallbackPlacements: i } = e;
+  return [
+    {
+      name: "offset",
+      options: {
+        offset: [0, t ?? 12]
+      }
+    },
+    {
+      name: "preventOverflow",
+      options: {
+        padding: {
+          top: 0,
+          bottom: 0,
+          left: 0,
+          right: 0
+        }
+      }
+    },
+    {
+      name: "flip",
+      options: {
+        padding: 5,
+        fallbackPlacements: i
+      }
+    },
+    {
+      name: "computeStyles",
+      options: {
+        gpuAcceleration: n
+      }
+    }
+  ];
+}
+function a(e, t) {
+  t && (e.modifiers = [...e.modifiers, ...t ?? []]);
+}
+export {
+  u as buildPopperOptions,
+  d as unwrapMeasurableEl
+};

package/dist/components/radio/radio.d.ts

@@ -42,10 +42,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
 }>, {
     readonly name: string;
+    readonly label: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
     readonly disabled: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
-    readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
     readonly value: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
-    readonly label: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
+    readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
     readonly border: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/components/radio-button/radio-button.d.ts

@@ -32,9 +32,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly name: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
 }>> & Readonly<{}>, {
     readonly name: string;
+    readonly label: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
     readonly disabled: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
-    readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
     readonly value: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
-    readonly label: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
+    readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/components/radio-group/radio-group.d.ts

@@ -55,10 +55,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>, {
     readonly props: import("element-plus").radioOptionProp;
     readonly name: string;
-    readonly fill: string;
     readonly type: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "button" | "radio", unknown>;
-    readonly id: string;
+    readonly fill: string;
     readonly disabled: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly id: string;
     readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
     readonly validateEvent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     readonly textColor: string;

package/dist/components/slot/index.d.ts

@@ -0,0 +1,3 @@
+import { OnlyChild } from "./src/only-child";
+export { OnlyChild as ElOnlyChild, OnlyChild };
+export * from './src/only-child';

package/dist/components/slot/src/only-child.d.ts

@@ -0,0 +1,7 @@
+import type { Ref, VNode } from 'vue';
+export declare const OnlyChild: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type OnlyChildExpose = {
+    forwardRef: Ref<HTMLElement>;
+};

package/dist/components/slot/src/only-child.js

@@ -0,0 +1,55 @@
+import { defineComponent as p, inject as h, withDirectives as g, cloneVNode as C, Comment as u, Fragment as N, Text as O } from "vue";
+import { NOOP as v, isObject as y } from "../../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { debugWarn as f } from "../../../utils/error.js";
+import { useNamespace as E } from "../../../hooks/use-namespace/index.js";
+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 "../../../hooks/use-model-toggle/index.js";
+import { FORWARD_REF_INJECTION_KEY as F, useForwardRefDirective as R } from "../../../hooks/use-forward-ref/index.js";
+import "../../../hooks/use-empty-values/index.js";
+const i = "ElOnlyChild", I = p({
+  name: i,
+  setup(r, { slots: t, attrs: n }) {
+    const e = h(F), a = R(
+      (e == null ? void 0 : e.setForwardRef) ?? v
+    );
+    return () => {
+      var l;
+      const o = (l = t.default) == null ? void 0 : l.call(t, n);
+      if (!o) return null;
+      const [c, s] = d(o);
+      return c ? (s > 1 && f(i, "requires exact only one valid child."), g(C(c, n), [
+        [a]
+      ])) : (f(i, "no valid child node found"), null);
+    };
+  }
+});
+function d(r) {
+  if (!r) return [null, 0];
+  const t = r, n = t.filter((e) => e.type !== u).length;
+  for (const e of t) {
+    if (y(e))
+      switch (e.type) {
+        case u:
+          continue;
+        case O:
+        case "svg":
+          return [m(e), n];
+        case N:
+          return d(e.children);
+        default:
+          return [e, n];
+      }
+    return [m(e), n];
+  }
+  return [null, 0];
+}
+function m(r) {
+  const t = E("only-child");
+  return /* @__PURE__ */ React.createElement("span", { class: t.e("content") }, r);
+}
+export {
+  I as OnlyChild
+};

package/dist/components/tab-pane/tab-pane.d.ts

@@ -23,9 +23,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly disabled: BooleanConstructor;
     readonly lazy: BooleanConstructor;
 }>> & Readonly<{}>, {
-    readonly closable: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
-    readonly disabled: boolean;
     readonly label: string;
+    readonly disabled: boolean;
+    readonly closable: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     readonly lazy: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/components/tabs/tabs.d.ts

@@ -102,10 +102,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly type: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "" | "card" | "border-card", unknown>;
     readonly closable: boolean;
     readonly tabindex: import("element-plus/es/utils/index.mjs").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
-    readonly editable: boolean;
     readonly stretch: boolean;
+    readonly editable: boolean;
     readonly addable: boolean;
-    readonly tabPosition: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "top" | "bottom" | "right" | "left", unknown>;
+    readonly tabPosition: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "top" | "bottom" | "left" | "right", unknown>;
     readonly beforeLeave: (newName: TabPaneName, oldName: TabPaneName) => import("element-plus/es/utils/typescript.mjs").Awaitable<void | boolean>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/components/tag/EpTag.vue.d.ts

@@ -25,8 +25,8 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
     };
     readonly round: BooleanConstructor;
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    close: (evt: MouseEvent) => void;
     click: (evt: MouseEvent) => void;
+    close: (evt: MouseEvent) => void;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     readonly type: {
         readonly type: import("vue").PropType<typeof import("./tag").tagTypes[number]>;
@@ -48,12 +48,12 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
     };
     readonly round: BooleanConstructor;
 }>> & Readonly<{
-    onClose?: ((evt: MouseEvent) => any) | undefined;
     onClick?: ((evt: MouseEvent) => any) | undefined;
+    onClose?: ((evt: MouseEvent) => any) | undefined;
 }>, {
-    readonly type: "primary" | "success" | "warning" | "info" | "danger";
+    readonly type: "primary" | "success" | "info" | "warning" | "danger";
     readonly closable: boolean;
-    readonly effect: "light" | "dark" | "plain";
+    readonly effect: "dark" | "light" | "plain";
     readonly round: boolean;
     readonly disableTransitions: boolean;
     readonly hit: boolean;

package/dist/components/tag/EpTag.vue.js

@@ -0,0 +1,96 @@
+import { defineComponent as F, computed as K, openBlock as a, createElementBlock as u, normalizeStyle as C, normalizeClass as l, createElementVNode as m, renderSlot as h, withModifiers as y, unref as t, createVNode as c, withCtx as p, createCommentVNode as $, createBlock as L, Transition as P } from "vue";
+import { Close as E } from "../../node_modules/.pnpm/@element-plus_icons-vue@2.3.2_vue@3.5.40_typescript@5.9.3_/node_modules/@element-plus/icons-vue/dist/index.js";
+import { ElIcon as j } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/icon/index.js";
+import { useLocale as q } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/hooks/use-locale/index.js";
+import { useFormSize as A } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/form/src/hooks/use-form-common-props.js";
+import { tagEmits as D, tagProps as G } from "./tag.js";
+const H = {
+  class: /* @__PURE__ */ l("el-tag__content")
+}, J = ["aria-label"], O = {
+  class: /* @__PURE__ */ l("el-tag__content")
+}, Q = ["aria-label"], T = "el", z = "tag", v = /* @__PURE__ */ F({
+  name: "EpTag",
+  __name: "EpTag",
+  props: G,
+  emits: D,
+  setup(V, { emit: N }) {
+    const d = j, S = V, b = N, { t: f } = q(), B = A(), M = () => `${T}-${z}`, r = (e) => e ? `${T}-${z}--${e}` : "", i = (e, o = !0) => e && o ? `is-${e}` : "", _ = K(() => {
+      const { type: e, hit: o, effect: s, closable: n, round: I } = S;
+      return [
+        M(),
+        i("closable", n),
+        r(e || "primary"),
+        r(B.value),
+        r(s),
+        i("hit", o),
+        i("round", I)
+      ];
+    }), k = (e) => {
+      b("close", e);
+    }, g = (e) => {
+      b("click", e);
+    }, w = (e) => {
+      var o, s, n;
+      (n = (s = (o = e == null ? void 0 : e.component) == null ? void 0 : o.subTree) == null ? void 0 : s.component) != null && n.bum && (e.component.subTree.component.bum = null);
+    };
+    return (e, o) => e.disableTransitions ? (a(), u("span", {
+      key: 0,
+      class: l(_.value),
+      style: C({ backgroundColor: e.color }),
+      onClick: g
+    }, [
+      m("span", H, [
+        h(e.$slots, "default")
+      ]),
+      e.closable ? (a(), u("button", {
+        key: 0,
+        "aria-label": t(f)("el.tag.close"),
+        class: l("el-tag__close"),
+        type: "button",
+        onClick: y(k, ["stop"])
+      }, [
+        c(t(d), null, {
+          default: p(() => [
+            c(t(E))
+          ]),
+          _: 1
+        })
+      ], 8, J)) : $("", !0)
+    ], 6)) : (a(), L(P, {
+      key: 1,
+      name: "el-zoom-in-center",
+      appear: "",
+      onVnodeMounted: w
+    }, {
+      default: p(() => [
+        m("span", {
+          class: l(_.value),
+          style: C({ backgroundColor: e.color }),
+          onClick: g
+        }, [
+          m("span", O, [
+            h(e.$slots, "default")
+          ]),
+          e.closable ? (a(), u("button", {
+            key: 0,
+            "aria-label": t(f)("el.tag.close"),
+            class: l("el-tag__close"),
+            type: "button",
+            onClick: y(k, ["stop"])
+          }, [
+            c(t(d), null, {
+              default: p(() => [
+                c(t(E))
+              ]),
+              _: 1
+            })
+          ], 8, Q)) : $("", !0)
+        ], 6)
+      ]),
+      _: 3
+    }, 512));
+  }
+});
+export {
+  v as default
+};

package/dist/components/tag/EpTag2.vue.js

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

package/dist/components/tag/index.d.ts

@@ -1,4 +1,4 @@
 import type { Plugin } from 'vue';
-import { ElTag } from 'element-plus';
-export declare const EpTag: typeof ElTag & Plugin;
+import _EpTag from './EpTag.vue';
+export declare const EpTag: typeof _EpTag & Plugin;
 export default EpTag;

package/dist/components/tag/index.js

@@ -1,7 +1,6 @@
-import "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/index.js";
 import { withInstall as t } from "../../utils/with-install.js";
-import { ElTag as a } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/tag/index.js";
-const o = Object.assign({}, a, { name: "EpTag" }), r = t(o, "ep-tag");
+import o from "./EpTag.vue.js";
+const r = t(o, "ep-tag");
 export {
   r as EpTag
 };

package/dist/components/tag/tag.js

@@ -0,0 +1,38 @@
+const t = ["primary", "success", "info", "warning", "danger"], a = ["dark", "light", "plain"], n = {
+  /** 标签类型 */
+  type: {
+    type: String,
+    values: t,
+    default: "primary"
+  },
+  /** 是否可关闭 */
+  closable: Boolean,
+  /** 是否禁用渐变动画 */
+  disableTransitions: Boolean,
+  /** 是否有边框描边 */
+  hit: Boolean,
+  /** 背景色 */
+  color: String,
+  /** 标签尺寸 */
+  size: {
+    type: String,
+    values: ["", "large", "default", "small"]
+  },
+  /** 主题 */
+  effect: {
+    type: String,
+    values: a,
+    default: "light"
+  },
+  /** 是否为圆形标签 */
+  round: Boolean
+}, o = {
+  close: (e) => e instanceof MouseEvent,
+  click: (e) => e instanceof MouseEvent
+};
+export {
+  a as tagEffects,
+  o as tagEmits,
+  n as tagProps,
+  t as tagTypes
+};

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

@@ -1,4 +1,175 @@
-import type { Plugin } from 'vue';
-import { ElTooltip } from 'element-plus';
-export declare const EpTooltip: typeof ElTooltip & Plugin;
+import Tooltip from './src/tooltip.vue';
+import type { SFCWithInstall } from '@element-plus/utils';
+export declare const ElTooltip: SFCWithInstall<typeof Tooltip>;
+export * from './src/tooltip';
+export * from './src/trigger';
+export * from './src/content';
+export * from './src/constants';
+export declare const EpTooltip: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import(".").UseTooltipProps> & Readonly<{
+        onClose?: ((...args: any[]) => any) | undefined;
+        onOpen?: ((...args: any[]) => any) | undefined;
+        onHide?: ((...args: any[]) => any) | undefined;
+        onShow?: ((...args: any[]) => any) | undefined;
+        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+        "onBefore-show"?: ((...args: any[]) => any) | undefined;
+        "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+        contentRef: import("vue").Ref<import(".").TooltipContentInstance | undefined, import(".").TooltipContentInstance | undefined>;
+        isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+        updatePopper: () => void;
+        onOpen: (event?: Event, delay?: number) => void;
+        onClose: (event?: Event, delay?: number) => void;
+        hide: (event?: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        close: (...args: any[]) => void;
+        open: (...args: any[]) => void;
+        hide: (...args: any[]) => void;
+        show: (...args: any[]) => void;
+        "update:visible": (...args: any[]) => void;
+        "before-show": (...args: any[]) => void;
+        "before-hide": (...args: any[]) => void;
+    }, import("vue").PublicProps, {
+        offset: number;
+        teleported: boolean;
+        style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+        effect: import("../popper").PopperEffect;
+        role: typeof import("../popper").roleTypes[number];
+        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;
+        showArrow: boolean;
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        trigger: import("@element-plus/utils").Arrayable<import(".").TooltipTriggerType>;
+        triggerKeys: string[];
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import(".").UseTooltipProps> & Readonly<{
+        onClose?: ((...args: any[]) => any) | undefined;
+        onOpen?: ((...args: any[]) => any) | undefined;
+        onHide?: ((...args: any[]) => any) | undefined;
+        onShow?: ((...args: any[]) => any) | undefined;
+        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+        "onBefore-show"?: ((...args: any[]) => any) | undefined;
+        "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+        contentRef: import("vue").Ref<import(".").TooltipContentInstance | undefined, import(".").TooltipContentInstance | undefined>;
+        isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+        updatePopper: () => void;
+        onOpen: (event?: Event, delay?: number) => void;
+        onClose: (event?: Event, delay?: number) => void;
+        hide: (event?: Event) => void;
+    }, {}, {}, {}, {
+        offset: number;
+        teleported: boolean;
+        style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+        effect: import("../popper").PopperEffect;
+        role: typeof import("../popper").roleTypes[number];
+        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;
+        showArrow: boolean;
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        trigger: import("@element-plus/utils").Arrayable<import(".").TooltipTriggerType>;
+        triggerKeys: string[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import(".").UseTooltipProps> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+    onOpen?: ((...args: any[]) => any) | undefined;
+    onHide?: ((...args: any[]) => any) | undefined;
+    onShow?: ((...args: any[]) => any) | undefined;
+    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+    "onBefore-show"?: ((...args: any[]) => any) | undefined;
+    "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+}>, {
+    popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+    contentRef: import("vue").Ref<import(".").TooltipContentInstance | undefined, import(".").TooltipContentInstance | undefined>;
+    isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+    updatePopper: () => void;
+    onOpen: (event?: Event, delay?: number) => void;
+    onClose: (event?: Event, delay?: number) => void;
+    hide: (event?: Event) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+    open: (...args: any[]) => void;
+    hide: (...args: any[]) => void;
+    show: (...args: any[]) => void;
+    "update:visible": (...args: any[]) => void;
+    "before-show": (...args: any[]) => void;
+    "before-hide": (...args: any[]) => void;
+}, string, {
+    offset: number;
+    teleported: boolean;
+    style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+    effect: import("../popper").PopperEffect;
+    role: typeof import("../popper").roleTypes[number];
+    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;
+    showArrow: boolean;
+    showAfter: number;
+    hideAfter: number;
+    autoClose: number;
+    trigger: import("@element-plus/utils").Arrayable<import(".").TooltipTriggerType>;
+    triggerKeys: string[];
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?: (props: {}) => any;
+    } & {
+        content?: (props: {}) => any;
+    };
+}) & import("vue").Plugin;
 export default EpTooltip;

package/dist/components/tooltip/index.js

@@ -1,7 +1,20 @@
-import "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/index.js";
-import { withInstall as o } from "../../utils/with-install.js";
-import { ElTooltip as t } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/tooltip/index.js";
-const p = Object.assign({}, t, { name: "EpTooltip" }), r = o(p, "ep-tooltip");
+import { withInstall as t } from "../../utils/with-install.js";
+import "vue";
+import { withInstall as p } from "../../utils/vue/install.js";
+import o from "./src/tooltip.vue.js";
+import { tooltipEmits as g, useTooltipModelToggle as f, useTooltipModelToggleEmits as n, useTooltipModelToggleProps as u } from "./src/tooltip.js";
+import { useTooltipTriggerProps as P, useTooltipTriggerPropsDefaults as x } from "./src/trigger.js";
+import { useTooltipContentProps as h, useTooltipContentPropsDefaults as w } from "./src/content.js";
+p(o);
+const s = t(o, "ep-tooltip");
 export {
-  r as EpTooltip
+  s as EpTooltip,
+  g as tooltipEmits,
+  h as useTooltipContentProps,
+  w as useTooltipContentPropsDefaults,
+  f as useTooltipModelToggle,
+  n as useTooltipModelToggleEmits,
+  u as useTooltipModelToggleProps,
+  P as useTooltipTriggerProps,
+  x as useTooltipTriggerPropsDefaults
 };

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

@@ -0,0 +1,18 @@
+import type { Arrayable } from '@element-plus/utils';
+import type { InjectionKey, Ref } from 'vue';
+import type { TooltipTriggerType } from './trigger';
+export type ElTooltipInjectionContext = {
+    controlled: Ref<boolean>;
+    id: Ref<string>;
+    open: Ref<boolean>;
+    trigger: Ref<Arrayable<TooltipTriggerType>>;
+    onOpen: (e?: Event) => void;
+    onClose: (e?: Event) => void;
+    onToggle: (e: Event) => void;
+    onShow: () => void;
+    onHide: () => void;
+    onBeforeShow: () => void;
+    onBeforeHide: () => void;
+    updatePopper: () => void;
+};
+export declare const TOOLTIP_INJECTION_KEY: InjectionKey<ElTooltipInjectionContext>;

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

@@ -0,0 +1,4 @@
+const o = Symbol("elTooltip");
+export {
+  o as TOOLTIP_INJECTION_KEY
+};