ep-craft 0.1.19 → 0.1.21

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

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

@@ -0,0 +1,90 @@
+import type { TooltipContentInstance } from './content';
+import type { UseTooltipProps } from './tooltip';
+import type { PopperInstance } from '@element-plus/components/popper';
+declare var __VLS_10: {}, __VLS_17: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+} & {
+    content?: (props: typeof __VLS_17) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<UseTooltipProps, {
+    /**
+     * @description el-popper component instance
+     */
+    popperRef: import("vue").Ref<PopperInstance | undefined, PopperInstance | undefined>;
+    /**
+     * @description el-tooltip-content component instance
+     */
+    contentRef: import("vue").Ref<TooltipContentInstance | undefined, TooltipContentInstance | undefined>;
+    /**
+     * @description validate current focus event is trigger inside el-tooltip-content
+     */
+    isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+    /**
+     * @description update el-popper component instance
+     */
+    updatePopper: () => void;
+    /**
+     * @description expose onOpen function to mange el-tooltip open state
+     */
+    onOpen: (event?: Event, delay?: number) => void;
+    /**
+     * @description expose onClose function to manage el-tooltip close state
+     */
+    onClose: (event?: Event, delay?: number) => void;
+    /**
+     * @description expose hide function
+     */
+    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, import("vue").PublicProps, Readonly<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;
+}>, {
+    offset: number;
+    teleported: boolean;
+    style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+    effect: import("@element-plus/components/popper").PopperEffect;
+    role: typeof import("@element-plus/components/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("./trigger").TooltipTriggerType>;
+    triggerKeys: string[];
+}, {}, {}, {}, 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;
+    };
+};