@talex-touch/tuffex 0.3.3 → 0.3.4

package/dist/es/flip-overlay/src/TxFlipOverlay.vue3.js

@@ -0,0 +1,6 @@
+import _sfc_main from './TxFlipOverlay.vue.js';
+/* empty css                   */
+
+
+
+export { _sfc_main as default };

package/dist/es/flip-overlay/src/types.d.ts

@@ -0,0 +1,53 @@
+import { CSSProperties } from 'vue';
+
+export interface FlipOverlayProps {
+    modelValue?: boolean;
+    source?: HTMLElement | DOMRect | null;
+    sourceRadius?: string | null;
+    duration?: number;
+    rotateX?: number;
+    rotateY?: number;
+    tiltRange?: number;
+    perspective?: number;
+    speedBoost?: number;
+    speedBoostAt?: number;
+    easeOut?: string;
+    easeIn?: string;
+    maskClosable?: boolean;
+    preventAccidentalClose?: boolean;
+    transitionName?: string;
+    maskClass?: string;
+    cardClass?: string;
+    cardStyle?: CSSProperties;
+    globalMask?: boolean;
+    border?: 'solid' | 'dashed' | 'dash' | 'none';
+    surface?: 'pure' | 'mask' | 'blur' | 'glass' | 'refraction';
+    surfaceColor?: string;
+    surfaceOpacity?: number;
+    header?: boolean;
+    headerTitle?: string;
+    headerDesc?: string;
+    closable?: boolean;
+    closeAriaLabel?: string;
+    scrollable?: boolean;
+    randomTilt?: boolean;
+    expanded?: boolean;
+    animating?: boolean;
+}
+export interface FlipOverlayEmits {
+    (e: 'update:modelValue', value: boolean): void;
+    (e: 'update:expanded', value: boolean): void;
+    (e: 'update:animating', value: boolean): void;
+    (e: 'open'): void;
+    (e: 'opened'): void;
+    (e: 'close'): void;
+    (e: 'closed'): void;
+}
+export interface FlipOverlaySlotProps {
+    close: () => void;
+    expanded: boolean;
+    animating: boolean;
+    closable: boolean;
+    headerTitle?: string;
+    headerDesc?: string;
+}

package/dist/es/floating/index.d.ts

@@ -0,0 +1,145 @@
+import { FloatingElementProps, FloatingProps } from './src/types';
+import { default as TxFloating } from './src/TxFloating.vue';
+import { default as TxFloatingElement } from './src/TxFloatingElement.vue';
+
+declare const Floating: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        disabled: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        className: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        sensitivity: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        easingFactor: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        disabled: boolean;
+        className: string;
+        sensitivity: number;
+        easingFactor: number;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        disabled: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        className: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        sensitivity: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        easingFactor: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        disabled: boolean;
+        className: string;
+        sensitivity: number;
+        easingFactor: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    disabled: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    className: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    sensitivity: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
+    easingFactor: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    disabled: boolean;
+    className: string;
+    sensitivity: number;
+    easingFactor: number;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+declare const FloatingElement: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        className: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        depth: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        className: string;
+        depth: number;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        className: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        depth: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        className: string;
+        depth: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    className: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    depth: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    className: string;
+    depth: number;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export { Floating, FloatingElement, TxFloating, TxFloatingElement };
+export type { FloatingElementProps, FloatingProps };
+export type TxFloatingInstance = InstanceType<typeof TxFloating>;
+export type TxFloatingElementInstance = InstanceType<typeof TxFloatingElement>;
+export default Floating;

package/dist/es/floating/index.js

@@ -0,0 +1,8 @@
+import { withInstall } from '../packages/tuffex/packages/utils/withInstall.js';
+import TxFloating from './src/TxFloating.vue.js';
+import TxFloatingElement from './src/TxFloatingElement.vue.js';
+
+const Floating = withInstall(TxFloating);
+const FloatingElement = withInstall(TxFloatingElement);
+
+export { Floating, FloatingElement, TxFloating, TxFloatingElement, Floating as default };

package/dist/es/floating/src/TxFloating.vue.d.ts

@@ -0,0 +1,45 @@
+import { FloatingProps } from './types';
+
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FloatingProps>, {
+    className: string;
+    sensitivity: number;
+    easingFactor: number;
+    disabled: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FloatingProps>, {
+    className: string;
+    sensitivity: number;
+    easingFactor: number;
+    disabled: boolean;
+}>>> & Readonly<{}>, {
+    disabled: boolean;
+    className: string;
+    sensitivity: number;
+    easingFactor: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/floating/src/TxFloating.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from './TxFloating.vue2.js';
+/* empty css                */
+import _export_sfc from '../../_virtual/_plugin-vue_export-helper.js';
+
+const TxFloating = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-b7626a70"]]);
+
+export { TxFloating as default };

package/dist/es/floating/src/TxFloating.vue2.js

@@ -0,0 +1,118 @@
+import { defineComponent, ref, provide, watch, onMounted, onBeforeUnmount, createElementBlock, openBlock, normalizeClass, renderSlot } from 'vue';
+import { hasWindow } from '../../packages/tuffex/packages/utils/env.js';
+import { TX_FLOATING_CONTEXT_KEY } from './context.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "TxFloating"
+  },
+  __name: "TxFloating",
+  props: {
+    className: { default: "" },
+    sensitivity: { default: 1 },
+    easingFactor: { default: 0.05 },
+    disabled: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const containerRef = ref(null);
+    const elementsMap = /* @__PURE__ */ new Map();
+    const mousePosition = { x: 0, y: 0 };
+    let rafId = null;
+    function updatePosition(x, y) {
+      const container = containerRef.value;
+      if (container) {
+        const rect = container.getBoundingClientRect();
+        mousePosition.x = x - rect.left;
+        mousePosition.y = y - rect.top;
+        return;
+      }
+      mousePosition.x = x;
+      mousePosition.y = y;
+    }
+    function handleMouseMove(event) {
+      updatePosition(event.clientX, event.clientY);
+    }
+    function handleTouchMove(event) {
+      const touch = event.touches[0];
+      if (!touch)
+        return;
+      updatePosition(touch.clientX, touch.clientY);
+    }
+    function registerElement(id, element, depth) {
+      const existing = elementsMap.get(id);
+      const currentPosition = existing?.currentPosition ?? { x: 0, y: 0 };
+      elementsMap.set(id, {
+        element,
+        depth,
+        currentPosition
+      });
+    }
+    function unregisterElement(id) {
+      elementsMap.delete(id);
+    }
+    function resetPositions() {
+      elementsMap.forEach((data) => {
+        data.currentPosition.x = 0;
+        data.currentPosition.y = 0;
+        data.element.style.transform = "translate3d(0px, 0px, 0)";
+      });
+    }
+    function animate() {
+      if (!props.disabled) {
+        elementsMap.forEach((data) => {
+          const strength = data.depth * props.sensitivity / 20;
+          const targetX = mousePosition.x * strength;
+          const targetY = mousePosition.y * strength;
+          const dx = targetX - data.currentPosition.x;
+          const dy = targetY - data.currentPosition.y;
+          data.currentPosition.x += dx * props.easingFactor;
+          data.currentPosition.y += dy * props.easingFactor;
+          data.element.style.transform = `translate3d(${data.currentPosition.x}px, ${data.currentPosition.y}px, 0)`;
+        });
+      }
+      rafId = requestAnimationFrame(animate);
+    }
+    function startListeners() {
+      if (!hasWindow())
+        return;
+      window.addEventListener("mousemove", handleMouseMove, { passive: true });
+      window.addEventListener("touchmove", handleTouchMove, { passive: true });
+      rafId = requestAnimationFrame(animate);
+    }
+    function stopListeners() {
+      if (!hasWindow())
+        return;
+      window.removeEventListener("mousemove", handleMouseMove);
+      window.removeEventListener("touchmove", handleTouchMove);
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
+    }
+    provide(TX_FLOATING_CONTEXT_KEY, {
+      registerElement,
+      unregisterElement
+    });
+    watch(() => props.disabled, (disabled) => {
+      if (disabled)
+        resetPositions();
+    });
+    onMounted(startListeners);
+    onBeforeUnmount(() => {
+      stopListeners();
+      elementsMap.clear();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "containerRef",
+        ref: containerRef,
+        class: normalizeClass(["tx-floating", props.className])
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 2);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/floating/src/TxFloatingElement.vue.d.ts

@@ -0,0 +1,39 @@
+import { FloatingElementProps } from './types';
+
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FloatingElementProps>, {
+    className: string;
+    depth: number;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FloatingElementProps>, {
+    className: string;
+    depth: number;
+}>>> & Readonly<{}>, {
+    className: string;
+    depth: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/floating/src/TxFloatingElement.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from './TxFloatingElement.vue2.js';
+/* empty css                       */
+import _export_sfc from '../../_virtual/_plugin-vue_export-helper.js';
+
+const TxFloatingElement = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-f95bcede"]]);
+
+export { TxFloatingElement as default };

package/dist/es/floating/src/TxFloatingElement.vue2.js

@@ -0,0 +1,43 @@
+import { defineComponent, ref, useId, inject, onMounted, watch, onBeforeUnmount, createElementBlock, openBlock, normalizeClass, renderSlot } from 'vue';
+import { TX_FLOATING_CONTEXT_KEY } from './context.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "TxFloatingElement"
+  },
+  __name: "TxFloatingElement",
+  props: {
+    className: { default: "" },
+    depth: { default: 1 }
+  },
+  setup(__props) {
+    const props = __props;
+    const elementRef = ref(null);
+    const elementId = useId();
+    const context = inject(TX_FLOATING_CONTEXT_KEY, null);
+    function register() {
+      if (!context || !elementRef.value)
+        return;
+      const resolvedDepth = props.depth ?? 0.01;
+      context.registerElement(elementId, elementRef.value, resolvedDepth);
+    }
+    onMounted(register);
+    watch(() => props.depth, register);
+    onBeforeUnmount(() => {
+      if (!context)
+        return;
+      context.unregisterElement(elementId);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "elementRef",
+        ref: elementRef,
+        class: normalizeClass(["tx-floating-element", props.className])
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 2);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/floating/src/context.d.ts

@@ -0,0 +1,7 @@
+import { InjectionKey } from 'vue';
+
+export interface FloatingContext {
+    registerElement: (id: string, element: HTMLDivElement, depth: number) => void;
+    unregisterElement: (id: string) => void;
+}
+export declare const TX_FLOATING_CONTEXT_KEY: InjectionKey<FloatingContext>;

package/dist/es/floating/src/context.js

@@ -0,0 +1,3 @@
+const TX_FLOATING_CONTEXT_KEY = Symbol("TxFloatingContext");
+
+export { TX_FLOATING_CONTEXT_KEY };

package/dist/es/floating/src/types.d.ts

@@ -0,0 +1,10 @@
+export interface FloatingProps {
+    className?: string;
+    sensitivity?: number;
+    easingFactor?: number;
+    disabled?: boolean;
+}
+export interface FloatingElementProps {
+    className?: string;
+    depth?: number;
+}

package/dist/es/form/index.d.ts

@@ -12,12 +12,12 @@ declare const Form: {
             type: import('vue').PropType<FormSize>;
             default: string;
         };
-        model: {
-            type: import('vue').PropType<Record<string, any>>;
-        };
         rules: {
             type: import('vue').PropType<FormRules>;
         };
+        model: {
+            type: import('vue').PropType<Record<string, any>>;
+        };
         labelPosition: {
             type: import('vue').PropType<FormLabelPosition>;
             default: string;
@@ -53,12 +53,12 @@ declare const Form: {
             type: import('vue').PropType<FormSize>;
             default: string;
         };
-        model: {
-            type: import('vue').PropType<Record<string, any>>;
-        };
         rules: {
             type: import('vue').PropType<FormRules>;
         };
+        model: {
+            type: import('vue').PropType<Record<string, any>>;
+        };
         labelPosition: {
             type: import('vue').PropType<FormLabelPosition>;
             default: string;
@@ -89,12 +89,12 @@ declare const Form: {
         type: import('vue').PropType<FormSize>;
         default: string;
     };
-    model: {
-        type: import('vue').PropType<Record<string, any>>;
-    };
     rules: {
         type: import('vue').PropType<FormRules>;
     };
+    model: {
+        type: import('vue').PropType<Record<string, any>>;
+    };
     labelPosition: {
         type: import('vue').PropType<FormLabelPosition>;
         default: string;

package/dist/es/form/index.js

@@ -1,4 +1,4 @@
-import { withInstall } from '../utils/withInstall.js';
+import { withInstall } from '../packages/tuffex/packages/utils/withInstall.js';
 import TxForm from './src/TxForm.vue.js';
 import TxFormItem from './src/TxFormItem.vue.js';
 

package/dist/es/fusion/index.d.ts

@@ -23,10 +23,6 @@ declare const Fusion: {
             type: import('vue').PropType<boolean>;
             default: undefined;
         };
-        gap: {
-            type: import('vue').PropType<number>;
-            default: number;
-        };
         alpha: {
             type: import('vue').PropType<number>;
             default: number;
@@ -35,6 +31,10 @@ declare const Fusion: {
             type: import('vue').PropType<FusionDirection>;
             default: string;
         };
+        gap: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
         trigger: {
             type: import('vue').PropType<FusionTrigger>;
             default: string;
@@ -55,9 +55,9 @@ declare const Fusion: {
         easing: string;
         blur: number;
         modelValue: boolean;
-        gap: number;
         alpha: number;
         direction: FusionDirection;
+        gap: number;
         trigger: FusionTrigger;
         alphaOffset: number;
     }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
@@ -88,10 +88,6 @@ declare const Fusion: {
             type: import('vue').PropType<boolean>;
             default: undefined;
         };
-        gap: {
-            type: import('vue').PropType<number>;
-            default: number;
-        };
         alpha: {
             type: import('vue').PropType<number>;
             default: number;
@@ -100,6 +96,10 @@ declare const Fusion: {
             type: import('vue').PropType<FusionDirection>;
             default: string;
         };
+        gap: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
         trigger: {
             type: import('vue').PropType<FusionTrigger>;
             default: string;
@@ -117,9 +117,9 @@ declare const Fusion: {
         easing: string;
         blur: number;
         modelValue: boolean;
-        gap: number;
         alpha: number;
         direction: FusionDirection;
+        gap: number;
         trigger: FusionTrigger;
         alphaOffset: number;
     }>;
@@ -147,10 +147,6 @@ declare const Fusion: {
         type: import('vue').PropType<boolean>;
         default: undefined;
     };
-    gap: {
-        type: import('vue').PropType<number>;
-        default: number;
-    };
     alpha: {
         type: import('vue').PropType<number>;
         default: number;
@@ -159,6 +155,10 @@ declare const Fusion: {
         type: import('vue').PropType<FusionDirection>;
         default: string;
     };
+    gap: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
     trigger: {
         type: import('vue').PropType<FusionTrigger>;
         default: string;
@@ -179,9 +179,9 @@ declare const Fusion: {
     easing: string;
     blur: number;
     modelValue: boolean;
-    gap: number;
     alpha: number;
     direction: FusionDirection;
+    gap: number;
     trigger: FusionTrigger;
     alphaOffset: number;
 }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {

package/dist/es/fusion/index.js

@@ -1,4 +1,4 @@
-import { withInstall } from '../utils/withInstall.js';
+import { withInstall } from '../packages/tuffex/packages/utils/withInstall.js';
 import TxFusion from './src/TxFusion.vue.js';
 
 const Fusion = withInstall(TxFusion);

package/dist/es/fusion/src/TxFusion.vue.d.ts

@@ -38,9 +38,9 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     easing: string;
     blur: number;
     modelValue: boolean;
-    gap: number;
     alpha: number;
     direction: import('./types').FusionDirection;
+    gap: number;
     trigger: import('./types').FusionTrigger;
     alphaOffset: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;