rappel-ui 1.0.27 → 1.0.29

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

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

@@ -0,0 +1,83 @@
+import { useTransitionEmits as e } from "./use-transition-emit.mjs";
+import { Teleport as t, Transition as n, computed as r, createBlock as i, createVNode as a, defineComponent as o, mergeProps as s, openBlock as c, renderSlot as l, toHandlerKey as u, unref as d, withCtx as f } from "vue";
+//#region packages/components/transition/src/transition.vue?vue&type=script&setup=true&lang.ts
+var p = o({
+	name: "ReTransition",
+	__name: "transition",
+	props: {
+		appendTo: { default: "body" },
+		teleported: {
+			type: Boolean,
+			default: !0
+		},
+		defer: {
+			type: Boolean,
+			default: () => void 0
+		},
+		transition: { default: "" },
+		mode: { default: "default" },
+		cssTransition: {
+			type: Boolean,
+			default: !0
+		},
+		cssDuration: { default: 0 },
+		appear: {
+			type: Boolean,
+			default: !0
+		}
+	},
+	emits: [
+		"beforeEnter",
+		"enter",
+		"enterCancelled",
+		"afterEnter",
+		"beforeLeave",
+		"leave",
+		"leaveCancelled",
+		"afterLeave"
+	],
+	setup(o, { emit: p }) {
+		let { beforeEnter: m, beforeLeave: h, enter: g, leave: _, afterEnter: v, afterLeave: y, enterCancelled: b, leaveCancelled: x } = e(p), S = r(() => o.cssTransition ? null : "enter"), C = r(() => o.cssTransition ? null : "leave");
+		return (e, r) => (c(), i(t, {
+			disabled: !o.teleported,
+			defer: o.defer,
+			to: o.appendTo
+		}, [a(n, s({
+			name: o.transition,
+			type: "transition",
+			css: o.cssTransition,
+			duration: o.cssDuration,
+			appear: o.appear,
+			mode: o.mode
+		}, e.$attrs, {
+			onBeforeEnter: d(m),
+			onBeforeLeave: d(h)
+		}, { [u(S.value)]: d(g) }, { [u(C.value)]: d(_) }, {
+			onEnterCancelled: d(b),
+			onLeaveCancelled: d(x),
+			onAfterEnter: d(v),
+			onAfterLeave: d(y)
+		}), {
+			default: f(() => [l(e.$slots, "default")]),
+			_: 3
+		}, 16, [
+			"name",
+			"css",
+			"duration",
+			"appear",
+			"mode",
+			"onBeforeEnter",
+			"onBeforeLeave",
+			"onEnterCancelled",
+			"onLeaveCancelled",
+			"onAfterEnter",
+			"onAfterLeave"
+		])], 8, [
+			"disabled",
+			"defer",
+			"to"
+		]));
+	}
+});
+//#endregion
+export { p as default };

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

@@ -0,0 +1,21 @@
+export type TransitionMode = 'in-out' | 'out-in' | 'default';
+export interface TransitionProps {
+    appendTo?: string | HTMLElement;
+    teleported?: boolean;
+    defer?: boolean;
+    transition?: string;
+    mode?: TransitionMode;
+    cssTransition?: boolean;
+    cssDuration?: number;
+    appear?: boolean;
+}
+export interface TransitionEmits {
+    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];
+}

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

@@ -0,0 +1,12 @@
+import { EmitFn } from 'vue';
+import { TransitionEmits } from './types';
+export declare function useTransitionEmits(emits: EmitFn<TransitionEmits>): {
+    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-emit.mjs → transition/src/use-transition-emit.mjs}

@@ -1,10 +1,6 @@
-//#region packages/components/tooltip/src/use-emit.ts
+//#region packages/components/transition/src/use-transition-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),
 		enter: (t, n) => e("enter", t, n),
 		enterCancelled: (t) => e("enterCancelled", t),
@@ -16,4 +12,4 @@ function e(e) {
 	};
 }
 //#endregion
-export { e as useEmits };
+export { e as useTransitionEmits };