rappel-ui 1.0.28 → 1.0.30

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

@@ -1,14 +1,25 @@
+import { StyleValue, DefineComponent, ComputedRef, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 import { TooltipProps } from './types';
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-import { VirtualElement } from '@floating-ui/vue';
+import { Placement, VirtualElement } from '@floating-ui/vue';
 type __VLS_Props = TooltipProps;
 type __VLS_ModelProps = {
     'visible'?: boolean;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_29: {};
+declare var __VLS_23: {
+    isHtml: boolean | undefined;
+    content: string;
+    zIndex: number;
+}, __VLS_25: {
+    showArrow: boolean;
+    arrowStyle: StyleValue;
+    placement: Placement;
+    zIndex: number;
+};
 type __VLS_Slots = {} & {
-    content?: (props: typeof __VLS_29) => any;
+    content?: (props: typeof __VLS_23) => any;
+} & {
+    arrow?: (props: typeof __VLS_25) => any;
 };
 declare const __VLS_base: DefineComponent<__VLS_PublicProps, {
     update: () => void;
@@ -16,14 +27,10 @@ declare const __VLS_base: DefineComponent<__VLS_PublicProps, {
     delayHide: (cb: () => void) => void;
     show: () => void;
     delayShow: () => void;
-    triggerRef: HTMLElement | VirtualElement | null | undefined;
-    floatingRef: HTMLElement | undefined;
-    arrowRef: HTMLElement | undefined;
+    triggerRef: ComputedRef<HTMLElement | VirtualElement | null | undefined>;
+    floatingRef: Readonly< ShallowRef<HTMLElement | null>>;
+    arrowRef: Readonly< ShallowRef<HTMLSpanElement | null, HTMLSpanElement | null>>;
 }, {}, {}, {}, ComponentOptionsMixin, 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;
     enterCancelled: (el: HTMLElement) => any;
@@ -34,10 +41,6 @@ declare const __VLS_base: DefineComponent<__VLS_PublicProps, {
     afterLeave: (el: HTMLElement) => any;
     "update:visible": (value: boolean) => any;
 }, string, 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;
     onEnterCancelled?: ((el: HTMLElement) => any) | undefined;

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

@@ -1,18 +1,20 @@
 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 n } from "./use-emit.mjs";
-import r from "./content.mjs";
-import { useTooltip as i } from "./use-tooltip.mjs";
-import { filterNodeTypes as ee, staticSideMap as a } from "./constants.mjs";
-import { Fragment as o, computed as s, createBlock as c, createElementBlock as l, createVNode as u, defineComponent as d, h as f, mergeModels as p, normalizeClass as m, normalizeStyle as h, onUnmounted as g, openBlock as _, ref as v, renderSlot as y, resolveDynamicComponent as te, toDisplayString as ne, unref as b, useModel as x, useSlots as S, useTemplateRef as C, withCtx as w } from "vue";
-import { arrow as T, autoUpdate as E, flip as D, inline as O, offset as k, useFloating as A } from "@floating-ui/vue";
+import { ReTransition as ee } from "../../transition/index.mjs";
+import { useTooltipEmits as te } from "./use-tooltip-emit.mjs";
+import { useTooltip as ne } from "./use-tooltip.mjs";
+import { filterNodeTypes as re, staticSideMap as i } from "./constants.mjs";
+import { Fragment as a, computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createVNode as ie, defineComponent as u, h as d, mergeModels as f, normalizeClass as p, normalizeStyle as m, onUnmounted as h, openBlock as g, ref as _, renderSlot as v, resolveDynamicComponent as ae, toDisplayString as oe, unref as y, useModel as se, useSlots as ce, useTemplateRef as b, watch as le, withCtx as ue } from "vue";
+import { arrow as x, autoUpdate as S, flip as C, inline as w, offset as T, useFloating as E } from "@floating-ui/vue";
 //#region packages/components/tooltip/src/tooltip.vue?vue&type=script&setup=true&lang.ts
-var j = ["innerHTML"], M = d({
+var D = ["innerHTML"], O = ["data-placement"], k = u({
 	name: "ReTooltip",
 	__name: "tooltip",
-	props: p({
+	props: f({
 		visible: { type: Boolean },
 		content: { default: "" },
 		isHtml: {
@@ -100,7 +102,8 @@ var j = ["innerHTML"], M = d({
 			type: Boolean,
 			default: () => void 0
 		},
-		virtualRef: { default: () => void 0 }
+		virtualRef: { default: () => void 0 },
+		zIndex: { default: () => void 0 }
 	}, {
 		visible: {
 			type: Boolean,
@@ -108,11 +111,7 @@ var j = ["innerHTML"], M = d({
 		},
 		visibleModifiers: {}
 	}),
-	emits: p([
-		"beforeShow",
-		"show",
-		"beforeHide",
-		"hide",
+	emits: f([
 		"beforeEnter",
 		"enter",
 		"enterCancelled",
@@ -122,142 +121,156 @@ var j = ["innerHTML"], M = d({
 		"leaveCancelled",
 		"afterLeave"
 	], ["update:visible"]),
-	setup(d, { expose: p, emit: M }) {
-		let { beforeShow: N, beforeHide: P, show: F, hide: I, beforeEnter: L, enter: R, afterEnter: z, beforeLeave: B, leave: re, afterLeave: V, enterCancelled: H, leaveCancelled: U } = n(M), { ns: W } = t("tooltip"), G = S(), K = s(() => {
+	setup(u, { expose: f, emit: k }) {
+		let { beforeEnter: A, enter: j, afterEnter: M, beforeLeave: N, leave: P, afterLeave: F, enterCancelled: I, leaveCancelled: L } = te(k), { ns: R, n: z, is: B } = t("tooltip"), V = ce(), H = o(() => {
 			var e, t;
-			let n = G == null || (e = G.default) == null || (e = e.call(G)) == null ? void 0 : e.filter((e) => e && !ee.includes(e.type.toString()))[0];
-			return (n == null || (t = n.type) == null ? void 0 : t.toString()) === "Symbol(v-txt)" ? f("span", {}, n) : n;
-		}), q = C("triggerRef"), J = C("floatingRef"), Y = v(), X = s(() => d.isVirtual ? d.virtualRef : d.isExternal ? Y.value : K.value ? q.value : null), Z = x(d, "visible"), { floatingStyles: ie, middlewareData: ae, placement: Q, update: oe } = A(X, s(() => {
-			var e;
-			return (e = J.value) == null ? void 0 : e.floatingRef;
-		}), {
-			open: Z,
-			placement: d.placement,
+			let n = V == null || (e = V.default) == null || (e = e.call(V)) == null ? void 0 : e.filter((e) => e && !re.includes(e.type.toString()))[0];
+			return (n == null || (t = n.type) == null ? void 0 : t.toString()) === "Symbol(v-txt)" ? d("span", {}, n) : n;
+		}), U = b("triggerRef"), W = b("floatingRef"), G = b("arrowRef"), K = _(), q = o(() => u.isVirtual ? u.virtualRef : u.isExternal ? K.value : H.value ? U.value : null), J = se(u, "visible"), { floatingStyles: de, middlewareData: fe, placement: Y, update: pe } = E(q, W, {
+			open: J,
+			placement: u.placement,
 			strategy: "absolute",
 			middleware: [
-				O(d.inlineOptions),
-				k(d.offset),
-				D({
-					padding: d.flipOffset,
-					boundary: d.boundary,
-					elementContext: d.elementContext,
-					altBoundary: d.altBoundary,
-					rootBoundary: d.rootBoundary,
-					...d.flipOptions
+				w(u.inlineOptions),
+				T(u.offset),
+				C({
+					padding: u.flipOffset,
+					boundary: u.boundary,
+					elementContext: u.elementContext,
+					altBoundary: u.altBoundary,
+					rootBoundary: u.rootBoundary,
+					...u.flipOptions
 				}),
-				T({
-					element: s(() => {
-						var e;
-						return (e = J.value) == null ? void 0 : e.arrowRef;
-					}),
-					padding: d.arrowOffset,
-					...d.arrowOptions
+				x({
+					element: G,
+					padding: u.arrowOffset,
+					...u.arrowOptions
 				})
 			],
-			whileElementsMounted: (e, t, n) => E(e, t, n, {
+			whileElementsMounted: (e, t, n) => S(e, t, n, {
 				animationFrame: !0,
 				ancestorScroll: !0,
 				ancestorResize: !0,
 				elementResize: !0,
 				layoutShift: !0
 			})
-		}), se = s(() => [ie.value, d.floatingStyle]), ce = s(() => {
-			let t = Q.value.split("-")[0], n = a[t], r = ae.value.arrow;
+		}), me = o(() => [de.value, u.floatingStyle]), X = o(() => {
+			let t = Y.value.split("-")[0], n = i[t], r = fe.value.arrow;
 			return {
 				position: "absolute",
 				left: (r == null ? void 0 : r.x) == null ? "" : `${r.x}px`,
 				top: (r == null ? void 0 : r.y) == null ? "" : `${r.y}px`,
-				[n]: `-${d.arrowSize / 2}px`,
-				width: e(d.arrowSize),
-				height: e(d.arrowSize)
+				[n]: `-${u.arrowSize / 2}px`,
+				width: e(u.arrowSize),
+				height: e(u.arrowSize)
 			};
-		}), le = s(() => d.isVirtual ? null : d.isExternal ? d.externalRef : K.value ? q.value : null), { stop: ue, setup: de, delayShow: fe, delayHide: pe } = i({
-			triggerRef: le,
-			isExternal: d.isExternal,
-			externalActiveRef: Y,
-			externalRef: s(() => d.externalRef),
-			trigger: d.trigger,
-			floatingRef: s(() => {
-				var e;
-				return d.persistent ? (e = J.value) == null ? void 0 : e.floatingRef : void 0;
-			}),
-			open: Z,
-			showDelay: d.showDelay,
-			hideDelay: d.hideDelay,
-			disabled: s(() => d.disabled)
-		}), { scope: $ } = de(), me = () => {
-			ue(), $ == null || $.stop();
-		};
-		return g(() => {
-			me();
-		}), p({
-			update: oe,
+		}), he = o(() => u.isVirtual ? null : u.isExternal ? u.externalRef : H.value ? U.value : null), { stop: ge, setup: _e, delayShow: ve, delayHide: ye } = ne({
+			triggerRef: he,
+			isExternal: u.isExternal,
+			externalActiveRef: K,
+			externalRef: o(() => u.externalRef),
+			trigger: u.trigger,
+			floatingRef: u.persistent ? W : void 0,
+			open: J,
+			showDelay: u.showDelay,
+			hideDelay: u.hideDelay,
+			disabled: o(() => u.disabled)
+		}), { scope: Z } = _e(), be = () => {
+			ge(), Z == null || Z.stop();
+		}, { currentTheme: Q } = r(u.theme, u.reverseTheme), xe = o(() => [me.value, {
+			width: e(u.width),
+			height: e(u.height),
+			maxWidth: e(u.maxWidth),
+			maxHeight: e(u.maxHeight),
+			zIndex: $.value
+		}]), $ = _(0), { zIndex: Se } = n(), { stop: Ce } = le(J, (e) => {
+			e && ($.value = u.zIndex || Se.value);
+		});
+		return h(() => {
+			be(), Ce();
+		}), f({
+			update: pe,
 			hide: () => {
-				Z.value = !1;
+				J.value = !1;
 			},
-			delayHide: pe,
+			delayHide: ye,
 			show: () => {
-				Z.value = !0;
+				J.value = !0;
 			},
-			delayShow: fe,
-			triggerRef: X.value,
-			floatingRef: s(() => {
-				var e;
-				return (e = J.value) == null ? void 0 : e.floatingRef;
-			}).value,
-			arrowRef: s(() => {
-				var e;
-				return (e = J.value) == null ? void 0 : e.arrowRef;
-			}).value
-		}), (e, t) => (_(), l(o, null, [(_(), c(te(K.value), {
+			delayShow: ve,
+			triggerRef: q,
+			floatingRef: W,
+			arrowRef: G
+		}), (e, t) => (g(), l(a, null, [(g(), s(ae(H.value), {
 			ref_key: "triggerRef",
-			ref: q,
-			class: m([b(W)("trigger")])
-		}, null, 8, ["class"])), u(r, {
-			ref_key: "floatingRef",
-			ref: J,
-			modelValue: Z.value,
-			"onUpdate:modelValue": t[0] || (t[0] = (e) => Z.value = e),
-			placement: b(Q),
-			"show-arrow": d.showArrow,
-			width: d.width,
-			height: d.height,
-			"max-width": d.maxWidth,
-			"max-height": d.maxHeight,
-			"floating-class": d.floatingClass,
-			style: h(se.value),
-			theme: d.theme,
-			"reverse-theme": d.reverseTheme,
-			"arrow-style": ce.value,
-			teleported: d.teleported,
-			"append-to": d.appendTo,
-			transition: d.transition,
-			"css-duration": d.cssDuration,
-			"css-transition": d.cssTransition,
-			onBeforeShow: b(N),
-			onShow: b(F),
-			onBeforeHide: b(P),
-			onHide: b(I),
-			onBeforeEnter: b(L),
-			onEnter: b(R),
-			onAfterEnter: b(z),
-			onBeforeLeave: b(B),
-			onLeave: b(re),
-			onAfterLeave: b(V),
-			onEnterCancelled: b(H),
-			onLeaveCancelled: b(U)
+			ref: U,
+			class: p([y(R)("trigger")])
+		}, null, 8, ["class"])), ie(y(ee), {
+			teleported: u.teleported,
+			"append-to": u.appendTo,
+			transition: u.transition,
+			"css-duration": u.cssDuration,
+			"css-transition": u.cssTransition,
+			onBeforeEnter: y(A),
+			onEnter: y(j),
+			onAfterEnter: y(M),
+			onBeforeLeave: y(N),
+			onLeave: y(P),
+			onAfterLeave: y(F),
+			onEnterCancelled: y(I),
+			onLeaveCancelled: y(L)
 		}, {
-			default: w(() => [y(e.$slots, "content", {}, () => [d.isHtml ? (_(), l("span", {
+			default: ue(() => [J.value ? (g(), l("div", {
 				key: 0,
-				class: m([b(W)("content")]),
-				innerHTML: d.content
-			}, null, 10, j)) : (_(), l("span", {
+				ref_key: "floatingRef",
+				ref: W,
+				style: m(xe.value),
+				class: p([
+					y(z)(),
+					y(B)(y(Q), !!y(Q)),
+					u.floatingClass
+				])
+			}, [v(e.$slots, "content", {
+				isHtml: u.isHtml,
+				content: u.content,
+				zIndex: $.value
+			}, () => [u.isHtml ? (g(), l("span", {
+				key: 0,
+				class: p([y(R)("content")]),
+				innerHTML: u.content
+			}, null, 10, D)) : (g(), l("span", {
 				key: 1,
-				class: m([b(W)("content")])
-			}, ne(d.content), 3))])]),
+				class: p([y(R)("content")])
+			}, oe(u.content), 3))]), v(e.$slots, "arrow", {
+				showArrow: u.showArrow,
+				arrowStyle: X.value,
+				placement: y(Y),
+				zIndex: $.value
+			}, () => [u.showArrow ? (g(), l("span", {
+				key: 0,
+				ref_key: "arrowRef",
+				ref: G,
+				"data-placement": y(Y),
+				style: m(X.value),
+				class: p([y(R)("arrow")])
+			}, null, 14, O)) : c("", !0)])], 6)) : c("", !0)]),
 			_: 3
-		}, 8, "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.onEnterCancelled.onLeaveCancelled".split("."))], 64));
+		}, 8, [
+			"teleported",
+			"append-to",
+			"transition",
+			"css-duration",
+			"css-transition",
+			"onBeforeEnter",
+			"onEnter",
+			"onAfterEnter",
+			"onBeforeLeave",
+			"onLeave",
+			"onAfterLeave",
+			"onEnterCancelled",
+			"onLeaveCancelled"
+		])], 64));
 	}
 });
 //#endregion
-export { M as default };
+export { k as default };

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

@@ -1,6 +1,7 @@
 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 '../../../types';
+import { TransitionMode, TransitionEmits } from '../..';
 export interface TooltipProps {
     visible?: boolean;
     content?: string;
@@ -44,6 +45,9 @@ export interface TooltipProps {
     externalRef?: HTMLElement | null;
     isVirtual?: boolean;
     virtualRef?: VirtualElement | null;
+    zIndex?: number;
+}
+export interface TooltipEmits extends TransitionEmits {
 }
 export interface TriggerOptions {
     triggerRef: Ref<HTMLElement | null | undefined>;
@@ -51,50 +55,11 @@ export interface TriggerOptions {
     externalRef?: ComputedRef<HTMLElement | null | undefined>;
     externalActiveRef: Ref<HTMLElement | null | undefined>;
     trigger: string;
-    floatingRef: ShallowRef<HTMLElement | null | undefined>;
+    floatingRef?: ShallowRef<HTMLElement | null>;
     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];
-    enterCancelled: [el: HTMLElement];
-    afterEnter: [el: HTMLElement];
-    beforeLeave: [el: HTMLElement];
-    leave: [el: HTMLElement, done: () => void];
-    leaveCancelled: [el: HTMLElement];
-    afterLeave: [el: HTMLElement];
-}
 export type { Placement, OffsetOptions, ShiftOptions, FlipOptions, ArrowOptions, VirtualElement, ElementContext, Boundary, RootBoundary, InlineOptions, HideOptions };

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

@@ -0,0 +1,12 @@
+import { EmitFn } from 'vue';
+import { TooltipEmits } from './types';
+export declare function useTooltipEmits(emits: EmitFn<TooltipEmits>): {
+    beforeEnter: (el: any) => void;
+    enter: (el: any, done: any) => void;
+    enterCancelled: (el: any) => void;
+    afterEnter: (el: any) => void;
+    beforeLeave: (el: any) => void;
+    leave: (el: any, done: any) => void;
+    leaveCancelled: (el: any) => void;
+    afterLeave: (el: any) => void;
+};

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

@@ -0,0 +1,7 @@
+import { useTransitionEmits as e } from "../../transition/src/use-transition-emit.mjs";
+//#region packages/components/tooltip/src/use-tooltip-emit.ts
+function t(t) {
+	return { ...e(t) };
+}
+//#endregion
+export { t as useTooltipEmits };

package/es/components/transition/index.d.ts

@@ -0,0 +1,67 @@
+import { CreateComponentPublicInstanceWithMixins, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
+import { TransitionProps } from '.';
+export * from './src/use-transition-emit';
+export * from './src/types';
+export declare const ReTransition: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< TransitionProps> & Readonly<{
+        onBeforeEnter?: ((el: HTMLElement) => any) | undefined;
+        onEnter?: ((el: HTMLElement, done: () => void) => any) | undefined;
+        onEnterCancelled?: ((el: HTMLElement) => any) | undefined;
+        onAfterEnter?: ((el: HTMLElement) => any) | undefined;
+        onBeforeLeave?: ((el: HTMLElement) => any) | undefined;
+        onLeave?: ((el: HTMLElement, done: () => void) => any) | undefined;
+        onLeaveCancelled?: ((el: HTMLElement) => any) | undefined;
+        onAfterLeave?: ((el: HTMLElement) => any) | undefined;
+    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        beforeEnter: (el: HTMLElement) => any;
+        enter: (el: HTMLElement, done: () => void) => any;
+        enterCancelled: (el: HTMLElement) => any;
+        afterEnter: (el: HTMLElement) => any;
+        beforeLeave: (el: HTMLElement) => any;
+        leave: (el: HTMLElement, done: () => void) => any;
+        leaveCancelled: (el: HTMLElement) => any;
+        afterLeave: (el: HTMLElement) => any;
+    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< TransitionProps> & Readonly<{
+        onBeforeEnter?: ((el: HTMLElement) => any) | undefined;
+        onEnter?: ((el: HTMLElement, done: () => void) => any) | undefined;
+        onEnterCancelled?: ((el: HTMLElement) => any) | undefined;
+        onAfterEnter?: ((el: HTMLElement) => any) | undefined;
+        onBeforeLeave?: ((el: HTMLElement) => any) | undefined;
+        onLeave?: ((el: HTMLElement, done: () => void) => any) | undefined;
+        onLeaveCancelled?: ((el: HTMLElement) => any) | undefined;
+        onAfterLeave?: ((el: HTMLElement) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< TransitionProps> & Readonly<{
+    onBeforeEnter?: ((el: HTMLElement) => any) | undefined;
+    onEnter?: ((el: HTMLElement, done: () => void) => any) | undefined;
+    onEnterCancelled?: ((el: HTMLElement) => any) | undefined;
+    onAfterEnter?: ((el: HTMLElement) => any) | undefined;
+    onBeforeLeave?: ((el: HTMLElement) => any) | undefined;
+    onLeave?: ((el: HTMLElement, done: () => void) => any) | undefined;
+    onLeaveCancelled?: ((el: HTMLElement) => any) | undefined;
+    onAfterLeave?: ((el: HTMLElement) => any) | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    beforeEnter: (el: HTMLElement) => any;
+    enter: (el: HTMLElement, done: () => void) => any;
+    enterCancelled: (el: HTMLElement) => any;
+    afterEnter: (el: HTMLElement) => any;
+    beforeLeave: (el: HTMLElement) => any;
+    leave: (el: HTMLElement, done: () => void) => any;
+    leaveCancelled: (el: HTMLElement) => any;
+    afterLeave: (el: HTMLElement) => any;
+}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        default?: (props: {}) => any;
+    };
+});
+export default ReTransition;

package/es/components/transition/index.mjs

@@ -0,0 +1,8 @@
+import { withInstall as e } from "../../utils/vue/index.mjs";
+import "../../utils/index.mjs";
+import { useTransitionEmits as t } from "./src/use-transition-emit.mjs";
+import n from "./src/transition.mjs";
+//#region packages/components/transition/index.ts
+var r = e(n);
+//#endregion
+export { r as ReTransition, r as default, t as useTransitionEmits };

package/es/components/transition/src/transition.mjs

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

package/es/components/transition/src/transition.vue.d.ts

@@ -0,0 +1,33 @@
+import { TransitionProps } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare var __VLS_20: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_20) => any;
+};
+declare const __VLS_base: DefineComponent<TransitionProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    beforeEnter: (el: HTMLElement) => any;
+    enter: (el: HTMLElement, done: () => void) => any;
+    enterCancelled: (el: HTMLElement) => any;
+    afterEnter: (el: HTMLElement) => any;
+    beforeLeave: (el: HTMLElement) => any;
+    leave: (el: HTMLElement, done: () => void) => any;
+    leaveCancelled: (el: HTMLElement) => any;
+    afterLeave: (el: HTMLElement) => any;
+}, string, PublicProps, Readonly<TransitionProps> & Readonly<{
+    onBeforeEnter?: ((el: HTMLElement) => any) | undefined;
+    onEnter?: ((el: HTMLElement, done: () => void) => any) | undefined;
+    onEnterCancelled?: ((el: HTMLElement) => any) | undefined;
+    onAfterEnter?: ((el: HTMLElement) => any) | undefined;
+    onBeforeLeave?: ((el: HTMLElement) => any) | undefined;
+    onLeave?: ((el: HTMLElement, done: () => void) => any) | undefined;
+    onLeaveCancelled?: ((el: HTMLElement) => any) | undefined;
+    onAfterLeave?: ((el: HTMLElement) => any) | undefined;
+}>, {}, {}, {}, {}, string, 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;
+    };
+};