rappel-ui 1.0.8 → 1.0.12

package/dist/es/components/tooltip/src/content.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,158 @@
+import { toPx as e } from "../../../utils/util.mjs";
+import "../../../utils/index.mjs";
+import { useNamespace as t } from "../../../composables/use-namespace/index.mjs";
+import { useZIndex as n } from "../../../composables/use-z-index/index.mjs";
+import { useTheme as r } from "../../../composables/use-theme/index.mjs";
+import "../../../composables/index.mjs";
+import { useEmits as i } from "./use-emit.mjs";
+import { Teleport as a, Transition as o, computed as s, createBlock as c, createCommentVNode as l, createElementBlock as u, createVNode as d, defineComponent as f, mergeModels as p, mergeProps as m, normalizeClass as h, normalizeStyle as g, onUnmounted as _, openBlock as v, ref as y, renderSlot as b, toHandlerKey as x, unref as S, useModel as C, useTemplateRef as w, watch as T, withCtx as E } from "vue";
+//#region packages/components/tooltip/src/content.vue?vue&type=script&setup=true&lang.ts
+var D = ["data-placement"], O = /*@__PURE__*/ f({
+	__name: "content",
+	props: /*@__PURE__*/ p({
+		modelValue: { type: Boolean },
+		style: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: () => void 0
+		},
+		arrowStyle: { default: () => void 0 },
+		appendTo: { default: "body" },
+		teleported: {
+			type: Boolean,
+			default: !0
+		},
+		defer: {
+			type: Boolean,
+			default: () => void 0
+		},
+		content: {},
+		placement: { default: "top" },
+		showArrow: {
+			type: Boolean,
+			default: !1
+		},
+		width: { default: () => void 0 },
+		height: { default: () => void 0 },
+		maxWidth: { default: () => void 0 },
+		maxHeight: { default: () => void 0 },
+		floatingClass: { default: () => void 0 },
+		transition: { default: "" },
+		mode: { default: () => void 0 },
+		cssTransition: {
+			type: Boolean,
+			default: !1
+		},
+		cssDuration: { default: 0 },
+		appear: {
+			type: Boolean,
+			default: !1
+		},
+		zIndex: { default: () => void 0 },
+		theme: { default: "light" },
+		reverseTheme: {
+			type: Boolean,
+			default: !1
+		}
+	}, {
+		modelValue: {
+			type: Boolean,
+			default: !1
+		},
+		modelModifiers: {}
+	}),
+	emits: /*@__PURE__*/ p([
+		"beforeShow",
+		"show",
+		"beforeHide",
+		"hide",
+		"beforeEnter",
+		"enter",
+		"afterEnter",
+		"beforeLeave",
+		"leave",
+		"afterLeave"
+	], ["update:modelValue"]),
+	setup(f, { expose: p, emit: O }) {
+		let k = C(f, "modelValue"), { beforeShow: A, show: j, beforeHide: M, hide: N, beforeEnter: P, beforeLeave: F, enter: ee, leave: I, afterEnter: L, afterLeave: R } = i(O), { n: z, ns: B, is: V } = t("tooltip"), { currentTheme: H } = r(f.theme, f.reverseTheme), U = w("floatingRef"), W = w("arrowRef"), G = s(() => [f.style, {
+			width: e(f.width),
+			height: e(f.height),
+			maxWidth: e(f.maxWidth),
+			maxHeight: e(f.maxHeight),
+			zIndex: K.value
+		}]), K = y(0), { zIndex: q } = n(), { stop: J } = T(k, (e) => {
+			e && (K.value = f.zIndex || q.value);
+		}), Y = s(() => f.cssTransition ? null : "enter"), X = s(() => f.cssTransition ? null : "leave"), Z = (e) => {
+			f.cssTransition ? A(e) : P(e);
+		}, Q = (e, t) => {
+			ee(e, t);
+		}, $ = (e) => {
+			f.cssTransition ? j(e) : L(e);
+		}, te = (e) => {
+			f.cssTransition ? M(e) : F(e);
+		}, ne = (e, t) => {
+			I(e, t);
+		}, re = (e) => {
+			f.cssTransition ? N(e) : R(e);
+		};
+		return _(() => {
+			J();
+		}), p({
+			floatingRef: U,
+			arrowRef: W
+		}), (e, t) => (v(), c(a, {
+			disabled: !f.teleported,
+			defer: f.defer,
+			to: f.appendTo
+		}, [d(o, m({
+			name: f.transition,
+			type: "transition",
+			css: f.cssTransition,
+			duration: f.cssDuration,
+			appear: f.appear,
+			mode: f.mode,
+			onBeforeEnter: Z,
+			onBeforeLeave: te
+		}, { [x(Y.value)]: Q }, { [x(X.value)]: ne }, {
+			onAfterEnter: $,
+			onAfterLeave: re
+		}), {
+			default: E(() => [k.value ? (v(), u("div", {
+				key: 0,
+				ref_key: "floatingRef",
+				ref: U,
+				style: g(G.value),
+				class: h([
+					S(z)(),
+					S(V)(S(H), !!S(H)),
+					f.floatingClass
+				])
+			}, [b(e.$slots, "default"), f.showArrow ? (v(), u("span", {
+				key: 0,
+				ref_key: "arrowRef",
+				ref: W,
+				"data-placement": f.placement,
+				style: g(f.arrowStyle),
+				class: h([S(B)("arrow")])
+			}, null, 14, D)) : l("", !0)], 6)) : l("", !0)]),
+			_: 3
+		}, 16, [
+			"name",
+			"css",
+			"duration",
+			"appear",
+			"mode"
+		])], 8, [
+			"disabled",
+			"defer",
+			"to"
+		]));
+	}
+});
+//#endregion
+export { O as default };

package/dist/es/components/tooltip/src/tooltip.mjs

@@ -0,0 +1,5 @@
+import e from "./tooltip.vue_vue_type_script_setup_true_lang.mjs";
+//#region packages/components/tooltip/src/tooltip.vue
+var t = e;
+//#endregion
+export { t as default };

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

@@ -0,0 +1,52 @@
+import { TooltipProps } from './types';
+type __VLS_Props = TooltipProps;
+type __VLS_ModelProps = {
+    'visible'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_27: {};
+type __VLS_Slots = {} & {
+    content?: (props: typeof __VLS_27) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {
+    update: () => void;
+    hide: () => void;
+    delayHide: (cb: () => void) => void;
+    show: () => void;
+    delayShow: () => void;
+    triggerRef: HTMLElement | import('@floating-ui/vue').VirtualElement | null | undefined;
+    floatingRef: HTMLElement | undefined;
+    arrowRef: HTMLElement | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    beforeShow: (el: HTMLElement) => any;
+    show: (el: HTMLElement) => any;
+    beforeHide: (el: HTMLElement) => any;
+    hide: (el: HTMLElement) => any;
+    beforeEnter: (el: HTMLElement) => any;
+    enter: (el: HTMLElement, done: () => void) => any;
+    afterEnter: (el: HTMLElement) => any;
+    beforeLeave: (el: HTMLElement) => any;
+    leave: (el: HTMLElement, done: () => void) => any;
+    afterLeave: (el: HTMLElement) => any;
+    "update:visible": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onBeforeShow?: ((el: HTMLElement) => any) | undefined;
+    onShow?: ((el: HTMLElement) => any) | undefined;
+    onBeforeHide?: ((el: HTMLElement) => any) | undefined;
+    onHide?: ((el: HTMLElement) => any) | undefined;
+    onBeforeEnter?: ((el: HTMLElement) => any) | undefined;
+    onEnter?: ((el: HTMLElement, done: () => void) => any) | undefined;
+    onAfterEnter?: ((el: HTMLElement) => any) | undefined;
+    onBeforeLeave?: ((el: HTMLElement) => any) | undefined;
+    onLeave?: ((el: HTMLElement, done: () => void) => any) | undefined;
+    onAfterLeave?: ((el: HTMLElement) => any) | undefined;
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/tooltip/src/tooltip.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,260 @@
+import { toPx as e } from "../../../utils/util.mjs";
+import "../../../utils/index.mjs";
+import { useNamespace as t } from "../../../composables/use-namespace/index.mjs";
+import "../../../composables/index.mjs";
+import { autoUpdate as n, flip as r, inline as i, offset as a } from "../../../node_modules/.pnpm/@floating-ui_dom@1.8.0/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs";
+import { arrow as o, useFloating as s } from "../../../node_modules/.pnpm/@floating-ui_vue@2.0.1_vue@3.5.26_typescript@5.9.3_/node_modules/@floating-ui/vue/dist/floating-ui.vue.mjs";
+import { useEmits as c } from "./use-emit.mjs";
+import l from "./content.mjs";
+import { useTooltip as u } from "./use-tooltip.mjs";
+import { filterNodeTypes as d, staticSideMap as f } from "./constants.mjs";
+import { Fragment as p, computed as m, createBlock as h, createElementBlock as g, createVNode as _, defineComponent as v, h as y, mergeModels as b, normalizeClass as x, normalizeStyle as ee, onUnmounted as te, openBlock as S, ref as C, renderSlot as w, resolveDynamicComponent as T, toDisplayString as E, unref as D, useModel as O, useSlots as k, useTemplateRef as A, withCtx as j } from "vue";
+//#region packages/components/tooltip/src/tooltip.vue?vue&type=script&setup=true&lang.ts
+var M = ["innerHTML"], N = /*@__PURE__*/ v({
+	name: "ReTooltip",
+	__name: "tooltip",
+	props: /*@__PURE__*/ b({
+		visible: { type: Boolean },
+		content: { default: "" },
+		isHtml: {
+			type: Boolean,
+			default: () => void 0
+		},
+		placement: { default: "top" },
+		delay: {},
+		width: { default: () => void 0 },
+		height: { default: () => void 0 },
+		maxWidth: { default: () => void 0 },
+		maxHeight: { default: () => void 0 },
+		trigger: { default: "hover" },
+		disabled: {
+			type: Boolean,
+			default: () => void 0
+		},
+		showDelay: { default: 0 },
+		hideDelay: { default: 200 },
+		showArrow: {
+			type: Boolean,
+			default: !0
+		},
+		floatingClass: { default: () => void 0 },
+		floatingStyle: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: () => void 0
+		},
+		theme: { default: "dark" },
+		reverseTheme: {
+			type: Boolean,
+			default: !1
+		},
+		offset: {
+			type: [
+				Number,
+				Object,
+				Function
+			],
+			default: 10
+		},
+		teleported: {
+			type: Boolean,
+			default: !0
+		},
+		appendTo: { default: "body" },
+		persistent: {
+			type: Boolean,
+			default: !0
+		},
+		boundary: { default: "clippingAncestors" },
+		elementContext: { default: "floating" },
+		altBoundary: {
+			type: Boolean,
+			default: !1
+		},
+		rootBoundary: { default: "viewport" },
+		transition: { default: "tooltip" },
+		mode: {},
+		cssTransition: {
+			type: Boolean,
+			default: !0
+		},
+		cssDuration: { default: 0 },
+		arrowSize: { default: 8 },
+		arrowOffset: { default: 4 },
+		arrowOptions: { default: () => void 0 },
+		shiftOptions: {},
+		flipOffset: { default: 8 },
+		flipOptions: { default: () => void 0 },
+		inlineOptions: { default: () => void 0 },
+		hideOptions: {},
+		isExternal: {
+			type: Boolean,
+			default: () => void 0
+		},
+		externalRef: { default: () => void 0 },
+		isVirtual: {
+			type: Boolean,
+			default: () => void 0
+		},
+		virtualRef: { default: () => void 0 }
+	}, {
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		visibleModifiers: {}
+	}),
+	emits: /*@__PURE__*/ b([
+		"beforeShow",
+		"show",
+		"beforeHide",
+		"hide",
+		"beforeEnter",
+		"enter",
+		"afterEnter",
+		"beforeLeave",
+		"leave",
+		"afterLeave"
+	], ["update:visible"]),
+	setup(v, { expose: b, emit: N }) {
+		let { beforeShow: P, beforeHide: F, show: I, hide: L, beforeEnter: R, enter: z, afterEnter: B, beforeLeave: V, leave: ne, afterLeave: H } = c(N), { ns: U } = t("tooltip"), W = k(), G = m(() => {
+			var e, t;
+			let n = W == null || (e = W.default) == null || (e = e.call(W)) == null ? void 0 : e.filter((e) => e && !d.includes(e.type.toString()))[0];
+			return (n == null || (t = n.type) == null ? void 0 : t.toString()) === "Symbol(v-txt)" ? y("span", {}, n) : n;
+		}), K = A("triggerRef"), q = A("floatingRef"), J = C(), Y = m(() => v.isVirtual ? v.virtualRef : v.isExternal ? J.value : G.value ? K.value : null), X = O(v, "visible"), { floatingStyles: Z, middlewareData: re, placement: Q, update: ie } = s(Y, m(() => {
+			var e;
+			return (e = q.value) == null ? void 0 : e.floatingRef;
+		}), {
+			open: X,
+			placement: v.placement,
+			strategy: "absolute",
+			middleware: [
+				i(v.inlineOptions),
+				a(v.offset),
+				r({
+					padding: v.flipOffset,
+					boundary: v.boundary,
+					elementContext: v.elementContext,
+					altBoundary: v.altBoundary,
+					rootBoundary: v.rootBoundary,
+					...v.flipOptions
+				}),
+				o({
+					element: m(() => {
+						var e;
+						return (e = q.value) == null ? void 0 : e.arrowRef;
+					}),
+					padding: v.arrowOffset,
+					...v.arrowOptions
+				})
+			],
+			whileElementsMounted: (e, t, r) => n(e, t, r, {
+				animationFrame: !0,
+				ancestorScroll: !0,
+				ancestorResize: !0,
+				elementResize: !0,
+				layoutShift: !0
+			})
+		}), ae = m(() => [Z.value, v.floatingStyle]), oe = m(() => {
+			let t = f[Q.value.split("-")[0]], n = re.value.arrow;
+			return {
+				position: "absolute",
+				left: (n == null ? void 0 : n.x) == null ? "" : `${n.x}px`,
+				top: (n == null ? void 0 : n.y) == null ? "" : `${n.y}px`,
+				[t]: `-${v.arrowSize / 2}px`,
+				width: e(v.arrowSize),
+				height: e(v.arrowSize)
+			};
+		}), { stop: se, setup: ce, delayShow: le, delayHide: ue } = u({
+			triggerRef: m(() => v.isVirtual ? void 0 : v.isExternal ? v.externalRef : G.value ? K.value : null),
+			isExternal: v.isExternal,
+			externalActiveRef: J,
+			externalRef: m(() => v.externalRef),
+			trigger: v.trigger,
+			floatingRef: m(() => {
+				var e;
+				return v.persistent ? (e = q.value) == null ? void 0 : e.floatingRef : void 0;
+			}),
+			open: X,
+			showDelay: v.showDelay,
+			hideDelay: v.hideDelay,
+			disabled: m(() => v.disabled)
+		}), { scope: $ } = ce(), de = () => {
+			se(), $ == null || $.stop();
+		};
+		return te(() => {
+			de();
+		}), b({
+			update: ie,
+			hide: () => {
+				X.value = !1;
+			},
+			delayHide: ue,
+			show: () => {
+				X.value = !0;
+			},
+			delayShow: le,
+			triggerRef: Y.value,
+			floatingRef: m(() => {
+				var e;
+				return (e = q.value) == null ? void 0 : e.floatingRef;
+			}).value,
+			arrowRef: m(() => {
+				var e;
+				return (e = q.value) == null ? void 0 : e.arrowRef;
+			}).value
+		}), (e, t) => (S(), g(p, null, [(S(), h(T(G.value), {
+			ref_key: "triggerRef",
+			ref: K,
+			class: x([D(U)("trigger")])
+		}, null, 8, ["class"])), _(l, {
+			ref_key: "floatingRef",
+			ref: q,
+			modelValue: X.value,
+			"onUpdate:modelValue": t[0] || (t[0] = (e) => X.value = e),
+			placement: D(Q),
+			"show-arrow": v.showArrow,
+			width: v.width,
+			height: v.height,
+			"max-width": v.maxWidth,
+			"max-height": v.maxHeight,
+			"floating-class": v.floatingClass,
+			style: ee(ae.value),
+			theme: v.theme,
+			"reverse-theme": v.reverseTheme,
+			"arrow-style": oe.value,
+			teleported: v.teleported,
+			"append-to": v.appendTo,
+			transition: v.transition,
+			"css-duration": v.cssDuration,
+			"css-transition": v.cssTransition,
+			onBeforeShow: D(P),
+			onShow: D(I),
+			onBeforeHide: D(F),
+			onHide: D(L),
+			onBeforeEnter: D(R),
+			onEnter: D(z),
+			onAfterEnter: D(B),
+			onBeforeLeave: D(V),
+			onLeave: D(ne),
+			onAfterLeave: D(H)
+		}, {
+			default: j(() => [w(e.$slots, "content", {}, () => [v.isHtml ? (S(), g("span", {
+				key: 0,
+				class: x([D(U)("content")]),
+				innerHTML: v.content
+			}, null, 10, M)) : (S(), g("span", {
+				key: 1,
+				class: x([D(U)("content")])
+			}, E(v.content), 3))])]),
+			_: 3
+		}, 8, /* @__PURE__ */ "modelValue.placement.show-arrow.width.height.max-width.max-height.floating-class.style.theme.reverse-theme.arrow-style.teleported.append-to.transition.css-duration.css-transition.onBeforeShow.onShow.onBeforeHide.onHide.onBeforeEnter.onEnter.onAfterEnter.onBeforeLeave.onLeave.onAfterLeave".split("."))], 64));
+	}
+});
+//#endregion
+export { N as default };

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

@@ -0,0 +1,98 @@
+import { ShallowRef, ComputedRef, Ref, StyleValue } from 'vue';
+import { Placement, OffsetOptions, ArrowOptions, ShiftOptions, FlipOptions, InlineOptions, HideOptions, Boundary, RootBoundary, ElementContext, VirtualElement } from '@floating-ui/vue';
+import { Theme, MaybeClass } from '@rappel-ui/types';
+export interface TooltipProps {
+    visible?: boolean;
+    content?: string;
+    isHtml?: boolean;
+    placement?: Placement;
+    delay?: number | string;
+    width?: number | string;
+    height?: number | string;
+    maxWidth?: number | string;
+    maxHeight?: number | string;
+    trigger?: Trigger;
+    disabled?: boolean;
+    showDelay?: number;
+    hideDelay?: number;
+    showArrow?: boolean;
+    floatingClass?: MaybeClass;
+    floatingStyle?: StyleValue;
+    theme?: Theme;
+    reverseTheme?: boolean;
+    offset?: number | OffsetOptions;
+    teleported?: boolean;
+    appendTo?: string | HTMLElement;
+    persistent?: boolean;
+    boundary?: Boundary | HTMLElement;
+    elementContext?: ElementContext;
+    altBoundary?: boolean;
+    rootBoundary?: RootBoundary;
+    transition?: string;
+    mode?: TransitionMode;
+    cssTransition?: boolean;
+    cssDuration?: number;
+    arrowSize?: number;
+    arrowOffset?: number;
+    arrowOptions?: ArrowOptions;
+    shiftOptions?: ShiftOptions;
+    flipOffset?: number;
+    flipOptions?: FlipOptions;
+    inlineOptions?: InlineOptions;
+    hideOptions?: HideOptions;
+    isExternal?: boolean;
+    externalRef?: HTMLElement;
+    isVirtual?: boolean;
+    virtualRef?: VirtualElement;
+}
+export interface TriggerOptions {
+    triggerRef: Ref<HTMLElement | null | undefined>;
+    isExternal?: boolean;
+    externalRef?: ComputedRef<HTMLElement | null | undefined>;
+    externalActiveRef: Ref<HTMLElement | null | undefined>;
+    trigger: string;
+    floatingRef: ShallowRef<HTMLElement | undefined>;
+    open: ShallowRef<boolean>;
+    showDelay?: number;
+    hideDelay?: number;
+    disabled?: ShallowRef<boolean | undefined> | ComputedRef<boolean | undefined>;
+}
+export type Trigger = 'hover' | 'click' | 'focus' | 'contextmenu';
+export type TransitionMode = 'in-out' | 'out-in' | 'default';
+export interface FloatingProps {
+    modelValue?: boolean;
+    style?: StyleValue;
+    arrowStyle?: Record<string, any>;
+    appendTo?: string | HTMLElement;
+    teleported?: boolean;
+    defer?: boolean;
+    content?: string;
+    placement?: string;
+    showArrow?: boolean;
+    width?: number | string;
+    height?: number | string;
+    maxWidth?: number | string;
+    maxHeight?: number | string;
+    floatingClass?: MaybeClass;
+    transition?: string;
+    mode?: TransitionMode;
+    cssTransition?: boolean;
+    cssDuration?: number;
+    appear?: boolean;
+    zIndex?: number;
+    theme?: Theme;
+    reverseTheme?: boolean;
+}
+export interface FloatingEmits {
+    beforeShow: [el: HTMLElement];
+    show: [el: HTMLElement];
+    beforeHide: [el: HTMLElement];
+    hide: [el: HTMLElement];
+    beforeEnter: [el: HTMLElement];
+    enter: [el: HTMLElement, done: () => void];
+    afterEnter: [el: HTMLElement];
+    beforeLeave: [el: HTMLElement];
+    leave: [el: HTMLElement, done: () => void];
+    afterLeave: [el: HTMLElement];
+}
+export type { Placement, OffsetOptions, ShiftOptions, FlipOptions, ArrowOptions, VirtualElement, ElementContext, Boundary, RootBoundary, InlineOptions, HideOptions };

package/dist/es/components/tooltip/src/use-emit.d.ts

@@ -0,0 +1,14 @@
+import { EmitFn } from 'vue';
+import { FloatingEmits } from './types';
+export declare function useEmits(emits: EmitFn<FloatingEmits>): {
+    beforeShow: (el: any) => void;
+    show: (el: any) => void;
+    beforeHide: (el: any) => void;
+    hide: (el: any) => void;
+    beforeEnter: (el: any) => void;
+    beforeLeave: (el: any) => void;
+    enter: (el: any, done: any) => void;
+    leave: (el: any, done: any) => void;
+    afterEnter: (el: any) => void;
+    afterLeave: (el: any) => void;
+};

package/dist/es/components/tooltip/src/use-emit.mjs

@@ -0,0 +1,17 @@
+//#region packages/components/tooltip/src/use-emit.ts
+function e(e) {
+	return {
+		beforeShow: (t) => e("beforeShow", t),
+		show: (t) => e("show", t),
+		beforeHide: (t) => e("beforeHide", t),
+		hide: (t) => e("hide", t),
+		beforeEnter: (t) => e("beforeEnter", t),
+		beforeLeave: (t) => e("beforeLeave", t),
+		enter: (t, n) => e("enter", t, n),
+		leave: (t, n) => e("leave", t, n),
+		afterEnter: (t) => e("afterEnter", t),
+		afterLeave: (t) => e("afterLeave", t)
+	};
+}
+//#endregion
+export { e as useEmits };

package/dist/es/components/tooltip/src/use-tooltip.d.ts

@@ -0,0 +1,11 @@
+import { EffectScope } from 'vue';
+import { TriggerOptions } from './types';
+export declare function useTooltip({ triggerRef, isExternal, externalActiveRef, externalRef, trigger, floatingRef, open, showDelay, hideDelay, disabled }: TriggerOptions): {
+    start: () => void;
+    stop: () => void;
+    setup: () => {
+        scope: EffectScope;
+    };
+    delayHide: (cb: () => void) => void;
+    delayShow: () => void;
+};