ep-craft 0.1.20 → 0.1.21

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
+};

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

@@ -0,0 +1,327 @@
+import type { AriaProps, UseDelayedToggleProps } from '@element-plus/hooks';
+import type { PopperContentProps } from '@element-plus/components/popper';
+import type TooltipContent from './content.vue';
+import type { ExtractPublicPropTypes } from 'vue';
+export interface ElTooltipContentProps extends UseDelayedToggleProps, Omit<PopperContentProps, 'visible'> {
+    /**
+     * @description which element the tooltip CONTENT appends to
+     */
+    appendTo?: string | HTMLElement;
+    /**
+     * @description display content, can be overridden by `slot#content`
+     */
+    content?: string;
+    /**
+     * @description whether `content` is treated as HTML string
+     */
+    rawContent?: boolean;
+    /**
+     * @description when tooltip inactive and `persistent` is `false` , popconfirm will be destroyed
+     */
+    persistent?: boolean;
+    /**
+     * @description visibility of Tooltip
+     */
+    visible?: boolean | null;
+    /**
+     * @description animation name
+     */
+    transition?: string;
+    /**
+     * @description whether tooltip content is teleported, if `true` it will be teleported to where `append-to` sets
+     */
+    teleported?: boolean;
+    /**
+     * @description whether Tooltip is disabled
+     */
+    disabled?: boolean;
+    ariaLabel?: AriaProps['ariaLabel'];
+}
+export declare const useTooltipContentPropsDefaults: {
+    readonly content: "";
+    readonly visible: null;
+    readonly teleported: true;
+    readonly effect: "dark";
+    readonly enterable: true;
+    readonly stopPopperMouseEvent: true;
+    readonly pure: false;
+    readonly focusOnShow: false;
+    readonly trapping: false;
+    readonly virtualTriggering: false;
+    readonly loop: false;
+    readonly style: undefined;
+    readonly popperStyle: undefined;
+    readonly arrowOffset: 5;
+    readonly boundariesPadding: 0;
+    readonly gpuAcceleration: true;
+    readonly offset: 12;
+    readonly placement: "bottom";
+    readonly popperOptions: () => {};
+    readonly strategy: "absolute";
+    readonly showAfter: 0;
+    readonly hideAfter: 200;
+    readonly autoClose: 0;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `ElTooltipContentProps` instead.
+ */
+export declare const useTooltipContentProps: {
+    readonly ariaLabel: StringConstructor;
+    readonly 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;
+    };
+    readonly content: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly rawContent: BooleanConstructor;
+    readonly persistent: BooleanConstructor;
+    readonly visible: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => boolean) | (() => boolean | null) | (((new (...args: any[]) => boolean) | (() => boolean | null)) | null)[], unknown, unknown, null, boolean>;
+    readonly transition: StringConstructor;
+    readonly teleported: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly loop: BooleanConstructor;
+    readonly id: StringConstructor;
+    readonly 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>;
+    readonly 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;
+    };
+    readonly 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>;
+    readonly enterable: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly pure: BooleanConstructor;
+    readonly focusOnShow: BooleanConstructor;
+    readonly trapping: BooleanConstructor;
+    readonly 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;
+    };
+    readonly 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>;
+    readonly referenceEl: {
+        readonly type: import("vue").PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly triggerTargetEl: {
+        readonly type: import("vue").PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly stopPopperMouseEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly virtualTriggering: BooleanConstructor;
+    readonly zIndex: NumberConstructor;
+    readonly arrowOffset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
+    readonly boundariesPadding: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly 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>;
+    readonly gpuAcceleration: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<StringConstructor, import("element-plus").Placement, unknown, "bottom", boolean>;
+    readonly 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>;
+    readonly strategy: import("@element-plus/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
+    readonly showAfter: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly hideAfter: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
+    readonly autoClose: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `ElTooltipContentProps` instead.
+ */
+export type ElTooltipContentPropsPublic = ExtractPublicPropTypes<typeof useTooltipContentProps>;
+export type TooltipContentInstance = InstanceType<typeof TooltipContent> & unknown;

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

@@ -0,0 +1,72 @@
+import { buildProps as o, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import "../../popper/index.js";
+import "../../../hooks/use-size/index.js";
+import "../../../hooks/use-z-index/index.js";
+import { useDelayedToggleProps as t, useDelayedTogglePropsDefaults as p } from "../../../hooks/use-delayed-toggle/index.js";
+import { useAriaProps as r } from "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { popperContentPropsDefaults as n, popperContentProps as l } from "../../popper/src/content.js";
+const b = {
+  ...p,
+  ...n,
+  content: "",
+  visible: null,
+  teleported: !0
+}, T = o({
+  ...t,
+  ...l,
+  /**
+   * @description which element the tooltip CONTENT appends to
+   */
+  appendTo: {
+    type: e([String, Object])
+  },
+  /**
+   * @description display content, can be overridden by `slot#content`
+   */
+  content: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description whether `content` is treated as HTML string
+   */
+  rawContent: Boolean,
+  /**
+   * @description when tooltip inactive and `persistent` is `false` , popconfirm will be destroyed
+   */
+  persistent: Boolean,
+  // because model toggle prop is generated dynamically
+  // so the typing cannot be evaluated by typescript as type:
+  // [name]: { type: Boolean, default: null }
+  // so we need to declare that again for type checking.
+  /**
+   * @description visibility of Tooltip
+   */
+  visible: {
+    type: e(Boolean),
+    default: null
+  },
+  /**
+   * @description animation name
+   */
+  transition: String,
+  /**
+   * @description whether tooltip content is teleported, if `true` it will be teleported to where `append-to` sets
+   */
+  teleported: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description whether Tooltip is disabled
+   */
+  disabled: Boolean,
+  ...r(["ariaLabel"])
+});
+export {
+  T as useTooltipContentProps,
+  b as useTooltipContentPropsDefaults
+};