gsap-nuxt-module 1.1.1 → 1.1.4

package/dist/module.d.mts

@@ -1,8 +1,11 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { gsapPlugins } from '../dist/runtime/gsap-plugins.js';
 
+type GSAPPluginName = keyof typeof gsapPlugins;
 interface ModuleOptions {
-    plugins?: ('Draggable' | 'EaselPlugin' | 'Flip' | 'MotionPathPlugin' | 'Observer' | 'PixiPlugin' | 'ScrollToPlugin' | 'ScrollTrigger' | 'TextPlugin' | 'RoughEase' | 'ExpoScaleEase' | 'SlowMo' | 'CustomEase')[];
+    plugins?: GSAPPluginName[];
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
-export { type ModuleOptions, _default as default };
+export { _default as default };
+export type { GSAPPluginName, ModuleOptions };

package/dist/module.json

@@ -4,9 +4,9 @@
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
-  "version": "1.1.1",
+  "version": "1.1.4",
   "builder": {
-    "@nuxt/module-builder": "0.8.4",
-    "unbuild": "2.0.0"
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
   }
 }

package/dist/module.mjs

@@ -1,7 +1,7 @@
 import { fileURLToPath } from 'node:url';
 import { defineNuxtModule, createResolver, addPlugin, addImportsDir } from '@nuxt/kit';
 
-const module = defineNuxtModule({
+const module$1 = defineNuxtModule({
   meta: {
     name: "gsap-nuxt-module",
     configKey: "gsap",
@@ -24,4 +24,4 @@ const module = defineNuxtModule({
   }
 });
 
-export { module as default };
+export { module$1 as default };

package/dist/runtime/composables/createGsapComposable.d.ts

@@ -0,0 +1,248 @@
+export declare const useScrollTrigger: () => {
+    new (vars: ScrollTrigger.StaticVars, animation?: gsap.core.Animation): {
+        readonly animation?: gsap.core.Animation | undefined;
+        readonly callbackAnimation?: gsap.core.Animation | undefined;
+        readonly direction: number;
+        readonly end: number;
+        readonly isActive: boolean;
+        readonly pin?: Element;
+        readonly progress: number;
+        readonly scroller: Element | Window;
+        readonly start: number;
+        readonly trigger?: Element;
+        readonly vars: ScrollTrigger.Vars;
+        disable(revert?: boolean, allowAnimation?: boolean): void;
+        enable(reset?: boolean, refresh?: boolean): void;
+        endAnimation(): void;
+        getTween(snap?: boolean): gsap.core.Tween;
+        getTrailing(name?: string | boolean | null): ScrollTrigger[];
+        getVelocity(): number;
+        kill(reset?: boolean, allowAnimation?: boolean): void;
+        labelToScroll(label: string): number;
+        next(): ScrollTrigger | undefined;
+        previous(): ScrollTrigger | undefined;
+        refresh(): void;
+        scroll(): number;
+        scroll(position: number): void;
+        tweenTo(position: number): gsap.core.Tween;
+        update(reset?: boolean, recordVelocity?: boolean, forceFake?: boolean): void;
+    };
+    readonly version: string;
+    readonly isTouch: number;
+    addEventListener(event: "scrollStart" | "scrollEnd" | "refreshInit" | "refresh" | "matchMedia" | "revert", callback: gsap.Callback): void;
+    batch(targets: gsap.DOMTarget, vars: ScrollTrigger.BatchVars): ScrollTrigger[];
+    clearMatchMedia(name?: string): void;
+    clearScrollMemory(scrollRestoration?: string): void;
+    config(vars: ScrollTrigger.ConfigVars): void;
+    create(vars: ScrollTrigger.StaticVars): ScrollTrigger;
+    defaults(vars: ScrollTrigger.StaticVars): ScrollTrigger.StaticVars;
+    getAll(): ScrollTrigger[];
+    disable(reset?: boolean, kill?: boolean): void;
+    enable(): void;
+    getById(id: string): ScrollTrigger | undefined;
+    getScrollFunc(element: gsap.DOMTarget | Window, horizontal?: boolean): ScrollTrigger.ScrollFunc;
+    isInViewport(element: Element | string, ratio?: number, horizontal?: boolean): boolean;
+    isScrolling(): boolean;
+    killAll(allowListeners?: boolean): void;
+    matchMedia(vars: ScrollTrigger.MatchMediaObject): void;
+    maxScroll(target: HTMLElement | Window, horizontal?: boolean): number;
+    normalizeScroll(enable?: boolean | ScrollTrigger.NormalizeVars | Observer): Observer | undefined;
+    normalizeScroll(): Observer | undefined;
+    observe(vars: Observer.ObserverVars): Observer;
+    positionInViewport(element: Element | string, referencePoint?: string | number, horizontal?: boolean): number;
+    refresh(safe?: boolean): void;
+    register(core: typeof gsap): void;
+    removeEventListener(event: "scrollStart" | "scrollEnd" | "refreshInit" | "refresh" | "matchMedia" | "revert", callback: gsap.Callback): void;
+    saveStyles(targets: gsap.DOMTarget): void;
+    scrollerProxy(scroller: gsap.DOMTarget, vars?: ScrollTrigger.ScrollerProxyVars): void;
+    snapDirectional(incrementOrArray: number | number[]): ScrollTrigger.SnapDirectionalFunc;
+    sort(func?: Function): ScrollTrigger[];
+    update(): void;
+};
+export declare const useScrollSmoother: () => {
+    new (vars: ScrollSmoother.Vars): {
+        readonly scrollTrigger: ScrollTrigger;
+        readonly progress: number;
+        readonly normalizer?: Observer;
+        content(element: gsap.DOMTarget): /*elided*/ any;
+        content(): HTMLElement;
+        effects(targets: gsap.DOMTarget, vars?: ScrollSmoother.EffectsVars | null): ScrollTrigger[];
+        effects(): ScrollTrigger[];
+        getVelocity(): number;
+        kill(): void;
+        offset(target: gsap.DOMTarget, position?: string, ignoreSpeed?: boolean): number;
+        paused(value: boolean): /*elided*/ any;
+        paused(): boolean;
+        refresh(soft?: boolean, force?: boolean): void;
+        scrollTo(target: gsap.DOMTarget | number, smooth?: boolean, position?: string): void;
+        scrollTop(position: number): /*elided*/ any;
+        scrollTop(): number;
+        smooth(value: number): void;
+        smooth(): number;
+        wrapper(element: gsap.DOMTarget): /*elided*/ any;
+        wrapper(): HTMLElement;
+    };
+    readonly version: string;
+    create(vars: ScrollSmoother.Vars): ScrollSmoother;
+    get(): ScrollSmoother | undefined;
+    refresh(safe?: boolean): void;
+};
+export declare const useSplitText: () => {
+    new (target: gsap.DOMTarget, vars?: SplitText.Vars): {
+        readonly chars: Element[];
+        readonly lines: Element[];
+        readonly words: Element[];
+        readonly masks: Element[];
+        readonly elements: Element[];
+        readonly isSplit: boolean;
+        kill(): void;
+        revert(): void;
+        split(vars: SplitText.Vars): SplitText;
+    };
+    create(target: gsap.DOMTarget, vars?: SplitText.Vars): SplitText;
+};
+export declare const useMotionPathHelper: () => {
+    new (target: gsap.DOMTarget, vars?: MotionPathHelper.Vars): {
+        kill(): void;
+    };
+    create(target: gsap.DOMTarget, vars?: MotionPathHelper.Vars): MotionPathHelper;
+    editPath(target: gsap.DOMTarget, vars?: MotionPathHelper.EditPathVars): MotionPathHelper;
+};
+export declare const useDraggable: () => {
+    new (target: gsap.DOMTarget, vars?: Draggable.Vars): {
+        readonly autoScroll: number;
+        readonly deltaX: number;
+        readonly deltaY: number;
+        readonly endRotation: number;
+        readonly endX: number;
+        readonly endY: number;
+        readonly isDragging: boolean;
+        readonly isPressed: boolean;
+        readonly isThrowing: boolean;
+        readonly lockAxis: boolean;
+        readonly maxRotation: number;
+        readonly maxX: number;
+        readonly maxY: number;
+        readonly minX: number;
+        readonly minY: number;
+        readonly minRotation: number;
+        readonly pointerEvent: TouchEvent | PointerEvent;
+        readonly pointerX: number;
+        readonly pointerY: number;
+        readonly rotation: number;
+        readonly scrollProxy: any;
+        readonly startX: number;
+        readonly startY: number;
+        readonly target: HTMLElement | SVGElement;
+        readonly tween: gsap.core.Tween;
+        readonly vars: Draggable.Vars;
+        readonly x: number;
+        readonly y: number;
+        addEventListener(type: Draggable.CallbackType, callback: gsap.Callback): void;
+        applyBounds(bounds: gsap.DOMTarget | Draggable.BoundsMinMax | Draggable.BoundsRectangle | Draggable.BoundsRotation): void;
+        disable(type?: string | object): /*elided*/ any;
+        dispatchEvent(type: Draggable.CallbackType): boolean;
+        enable(type?: string | object): /*elided*/ any;
+        enabled(value: boolean): /*elided*/ any;
+        enabled(): boolean;
+        endDrag(event: Event): void;
+        getDirection(from: "start" | "velocity" | gsap.DOMTarget): Draggable.Direction;
+        hitTest(testObject: Draggable.TestObject, threshold?: number | string): boolean;
+        kill(): /*elided*/ any;
+        removeEventListener(type: Draggable.CallbackType, callback: gsap.Callback): void;
+        startDrag(event: Event, align?: boolean): void;
+        timeSinceDrag(): number;
+        update(applyBounds?: boolean, sticky?: boolean): /*elided*/ any;
+    };
+    version: string;
+    zIndex: number;
+    create(target: gsap.DOMTarget, vars?: Draggable.Vars): Draggable[];
+    get(target: gsap.DOMTarget): Draggable;
+    hitTest(testObject1: Draggable.TestObject, testObject2: Draggable.TestObject, threshold?: number | string): boolean;
+    timeSinceDrag(): number;
+};
+export declare const useFlip: () => {
+    new (): {};
+    readonly version: string;
+    batch(id?: string): FlipBatch;
+    convertCoordinates(fromElement: Element, toElement: Element): gsap.plugins.Matrix2D;
+    convertCoordinates(fromElement: Element, toElement: Element, point: gsap.Point2D): gsap.Point2D;
+    fit(fromElement: gsap.DOMTarget, toElement: gsap.DOMTarget | Flip.FlipState, vars?: Flip.FitVars): gsap.core.Tween | object | null;
+    from(state: Flip.FlipState, vars?: Flip.FromToVars): gsap.core.Timeline;
+    getState(targets: gsap.DOMTarget, vars?: Flip.FlipStateVars | string): Flip.FlipState;
+    getByTarget(target: Element | string): gsap.core.Timeline | null;
+    isFlipping(target: gsap.DOMTarget): boolean;
+    killFlipsOf(targets: gsap.DOMTarget, complete?: boolean): void;
+    makeAbsolute(targets: gsap.DOMTarget | Flip.FlipState[]): Element[];
+    to(state: Flip.FlipState, vars?: Flip.FromToVars): gsap.core.Timeline;
+    register(core: typeof gsap): void;
+    ElementState: typeof Flip.ElementState;
+    FlipState: typeof Flip.FlipState;
+};
+export declare const useObserver: () => {
+    new (): {
+        readonly deltaX: number;
+        readonly deltaY: number;
+        readonly event: Event;
+        readonly isDragging: boolean;
+        readonly isEnabled: boolean;
+        readonly isPressed: boolean;
+        readonly startX?: number;
+        readonly startY?: number;
+        readonly target: Element;
+        readonly vars: Observer.ObserverVars;
+        readonly velocityX: number;
+        readonly velocityY: number;
+        readonly x?: number;
+        readonly y?: number;
+        readonly axis?: string | null;
+        disable(): void;
+        enable(): /*elided*/ any;
+        kill(): void;
+        scrollX(): number;
+        scrollX(position: number): void;
+        scrollY(): number;
+        scrollY(position: number): void;
+    };
+    readonly isTouch: number;
+    readonly eventTypes: string[];
+    readonly version: string;
+    create(vars: Observer.ObserverVars): Observer;
+    getAll(): Observer[];
+    getById(id: string): Observer | undefined;
+};
+export declare const useGSDevTools: () => {
+    new (target: gsap.DOMTarget, vars?: GSDevTools.Vars): {
+        kill(): void;
+    };
+    create(vars?: GSDevTools.Vars): GSDevTools;
+    getById(id: string): GSDevTools | null;
+};
+export declare const useCustomEase: () => {
+    new (id: string, data?: string | number[], config?: CustomEaseConfig): {
+        id: string;
+        ease: EaseFunction;
+        data: string | number[];
+        segment: number[];
+        setData(data?: string | number[], config?: CustomEaseConfig): /*elided*/ any;
+        getSVGData(config?: CustomEaseConfig): string;
+    };
+    create(id: string, data?: string | number[], config?: CustomEaseConfig): EaseFunction;
+    register(core: object): void;
+    get(id: string): EaseFunction;
+    getSVGData(ease: CustomEase | EaseFunction | string, config?: CustomEaseConfig): string;
+};
+export declare const useCustomWiggle: () => {
+    new (id: string, vars?: CustomWiggleVars): {
+        ease: EaseFunction;
+    };
+    create(id: string, vars?: CustomWiggleVars): EaseFunction;
+    register(core: object): void;
+};
+export declare const useCustomBounce: () => {
+    new (id: string, vars?: CustomBounceVars): {
+        ease: EaseFunction;
+    };
+    create(id: string, vars?: CustomBounceVars): EaseFunction;
+    register(core: object): void;
+};

package/dist/runtime/composables/createGsapComposable.js

@@ -0,0 +1,12 @@
+import { createGsapComposable } from "../create-gsap-composable.js";
+export const useScrollTrigger = createGsapComposable("ScrollTrigger");
+export const useScrollSmoother = createGsapComposable("ScrollSmoother");
+export const useSplitText = createGsapComposable("SplitText");
+export const useMotionPathHelper = createGsapComposable("MotionPathHelper");
+export const useDraggable = createGsapComposable("Draggable");
+export const useFlip = createGsapComposable("Flip");
+export const useObserver = createGsapComposable("Observer");
+export const useGSDevTools = createGsapComposable("GSDevTools");
+export const useCustomEase = createGsapComposable("CustomEase");
+export const useCustomWiggle = createGsapComposable("CustomWiggle");
+export const useCustomBounce = createGsapComposable("CustomBounce");

package/dist/runtime/create-gsap-composable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Factory to create GSAP plugin composables.
+ * @param pluginName - Name of the GSAP plugin as provided in nuxtApp injects.
+ * @param fallbackMessage - Optional error message for missing plugin.
+ */
+export declare function createGsapComposable<T>(pluginName: string, fallbackMessage?: string): () => T;

package/dist/runtime/create-gsap-composable.js

@@ -0,0 +1,13 @@
+import { useNuxtApp } from "#app";
+export function createGsapComposable(pluginName, fallbackMessage) {
+  return () => {
+    const nuxtApp = useNuxtApp();
+    const plugin = nuxtApp[`$${pluginName}`];
+    if (!plugin) {
+      throw new Error(
+        fallbackMessage || `[use${pluginName}] ${pluginName} is not registered! Did you enable it in nuxt.config.ts?`
+      );
+    }
+    return plugin;
+  };
+}

package/dist/runtime/gsap-plugins.d.ts

@@ -1,7 +1,147 @@
 /**
  * This object contains lazy-loaded GSAP plugins for use in the application.
+ *
  */
 export declare const gsapPlugins: {
+    ScrollTrigger: () => Promise<{
+        new (vars: ScrollTrigger.StaticVars, animation?: gsap.core.Animation): {
+            readonly animation?: gsap.core.Animation | undefined;
+            readonly callbackAnimation?: gsap.core.Animation | undefined;
+            readonly direction: number;
+            readonly end: number;
+            readonly isActive: boolean;
+            readonly pin?: Element;
+            readonly progress: number;
+            readonly scroller: Element | Window;
+            readonly start: number;
+            readonly trigger?: Element;
+            readonly vars: ScrollTrigger.Vars;
+            disable(revert?: boolean, allowAnimation?: boolean): void;
+            enable(reset?: boolean, refresh?: boolean): void;
+            endAnimation(): void;
+            getTween(snap?: boolean): gsap.core.Tween;
+            getTrailing(name?: string | boolean | null): ScrollTrigger[];
+            getVelocity(): number;
+            kill(reset?: boolean, allowAnimation?: boolean): void;
+            labelToScroll(label: string): number;
+            next(): ScrollTrigger | undefined;
+            previous(): ScrollTrigger | undefined;
+            refresh(): void;
+            scroll(): number;
+            scroll(position: number): void;
+            tweenTo(position: number): gsap.core.Tween;
+            update(reset?: boolean, recordVelocity?: boolean, forceFake?: boolean): void;
+        };
+        readonly version: string;
+        readonly isTouch: number;
+        addEventListener(event: "scrollStart" | "scrollEnd" | "refreshInit" | "refresh" | "matchMedia" | "revert", callback: gsap.Callback): void;
+        batch(targets: gsap.DOMTarget, vars: ScrollTrigger.BatchVars): ScrollTrigger[];
+        clearMatchMedia(name?: string): void;
+        clearScrollMemory(scrollRestoration?: string): void;
+        config(vars: ScrollTrigger.ConfigVars): void;
+        create(vars: ScrollTrigger.StaticVars): ScrollTrigger;
+        defaults(vars: ScrollTrigger.StaticVars): ScrollTrigger.StaticVars;
+        getAll(): ScrollTrigger[];
+        disable(reset?: boolean, kill?: boolean): void;
+        enable(): void;
+        getById(id: string): ScrollTrigger | undefined;
+        getScrollFunc(element: gsap.DOMTarget | Window, horizontal?: boolean): ScrollTrigger.ScrollFunc;
+        isInViewport(element: Element | string, ratio?: number, horizontal?: boolean): boolean;
+        isScrolling(): boolean;
+        killAll(allowListeners?: boolean): void;
+        matchMedia(vars: ScrollTrigger.MatchMediaObject): void;
+        maxScroll(target: HTMLElement | Window, horizontal?: boolean): number;
+        normalizeScroll(enable?: boolean | ScrollTrigger.NormalizeVars | Observer): Observer | undefined;
+        normalizeScroll(): Observer | undefined;
+        observe(vars: Observer.ObserverVars): Observer;
+        positionInViewport(element: Element | string, referencePoint?: string | number, horizontal?: boolean): number;
+        refresh(safe?: boolean): void;
+        register(core: typeof gsap): void;
+        removeEventListener(event: "scrollStart" | "scrollEnd" | "refreshInit" | "refresh" | "matchMedia" | "revert", callback: gsap.Callback): void;
+        saveStyles(targets: gsap.DOMTarget): void;
+        scrollerProxy(scroller: gsap.DOMTarget, vars?: ScrollTrigger.ScrollerProxyVars): void;
+        snapDirectional(incrementOrArray: number | number[]): ScrollTrigger.SnapDirectionalFunc;
+        sort(func?: Function): ScrollTrigger[];
+        update(): void;
+    }>;
+    ScrollToPlugin: () => Promise<{
+        new (): {};
+        config(vars: ScrollToPlugin.ConfigVars): void;
+        max(element: gsap.DOMTarget): number;
+        offset(element: gsap.DOMTarget, container?: gsap.DOMTarget): number;
+    }>;
+    ScrollSmoother: () => Promise<{
+        new (vars: ScrollSmoother.Vars): {
+            readonly scrollTrigger: ScrollTrigger;
+            readonly progress: number;
+            readonly normalizer?: Observer;
+            content(element: gsap.DOMTarget): /*elided*/ any;
+            content(): HTMLElement;
+            effects(targets: gsap.DOMTarget, vars?: ScrollSmoother.EffectsVars | null): ScrollTrigger[];
+            effects(): ScrollTrigger[];
+            getVelocity(): number;
+            kill(): void;
+            offset(target: gsap.DOMTarget, position?: string, ignoreSpeed?: boolean): number;
+            paused(value: boolean): /*elided*/ any;
+            paused(): boolean;
+            refresh(soft?: boolean, force?: boolean): void;
+            scrollTo(target: gsap.DOMTarget | number, smooth?: boolean, position?: string): void;
+            scrollTop(position: number): /*elided*/ any;
+            scrollTop(): number;
+            smooth(value: number): void;
+            smooth(): number;
+            wrapper(element: gsap.DOMTarget): /*elided*/ any;
+            wrapper(): HTMLElement;
+        };
+        readonly version: string;
+        create(vars: ScrollSmoother.Vars): ScrollSmoother;
+        get(): ScrollSmoother | undefined;
+        refresh(safe?: boolean): void;
+    }>;
+    SplitText: () => Promise<{
+        new (target: gsap.DOMTarget, vars?: SplitText.Vars): {
+            readonly chars: Element[];
+            readonly lines: Element[];
+            readonly words: Element[];
+            readonly masks: Element[];
+            readonly elements: Element[];
+            readonly isSplit: boolean;
+            kill(): void;
+            revert(): void;
+            split(vars: SplitText.Vars): SplitText;
+        };
+        create(target: gsap.DOMTarget, vars?: SplitText.Vars): SplitText;
+    }>;
+    ScrambleTextPlugin: () => Promise<gsap.plugins.ScrambleTextPlugin>;
+    TextPlugin: () => Promise<gsap.plugins.TextPlugin>;
+    DrawSVGPlugin: () => Promise<gsap.plugins.DrawSVGPlugin>;
+    MorphSVGPlugin: () => Promise<gsap.plugins.MorphSVGPlugin>;
+    MotionPathPlugin: () => Promise<gsap.plugins.MotionPathPlugin>;
+    MotionPathHelper: () => Promise<{
+        new (target: gsap.DOMTarget, vars?: MotionPathHelper.Vars): {
+            kill(): void;
+        };
+        create(target: gsap.DOMTarget, vars?: MotionPathHelper.Vars): MotionPathHelper;
+        editPath(target: gsap.DOMTarget, vars?: MotionPathHelper.EditPathVars): MotionPathHelper;
+    }>;
+    Flip: () => Promise<{
+        new (): {};
+        readonly version: string;
+        batch(id?: string): FlipBatch;
+        convertCoordinates(fromElement: Element, toElement: Element): gsap.plugins.Matrix2D;
+        convertCoordinates(fromElement: Element, toElement: Element, point: gsap.Point2D): gsap.Point2D;
+        fit(fromElement: gsap.DOMTarget, toElement: gsap.DOMTarget | Flip.FlipState, vars?: Flip.FitVars): gsap.core.Tween | object | null;
+        from(state: Flip.FlipState, vars?: Flip.FromToVars): gsap.core.Timeline;
+        getState(targets: gsap.DOMTarget, vars?: Flip.FlipStateVars | string): Flip.FlipState;
+        getByTarget(target: Element | string): gsap.core.Timeline | null;
+        isFlipping(target: gsap.DOMTarget): boolean;
+        killFlipsOf(targets: gsap.DOMTarget, complete?: boolean): void;
+        makeAbsolute(targets: gsap.DOMTarget | Flip.FlipState[]): Element[];
+        to(state: Flip.FlipState, vars?: Flip.FromToVars): gsap.core.Timeline;
+        register(core: typeof gsap): void;
+        ElementState: typeof Flip.ElementState;
+        FlipState: typeof Flip.FlipState;
+    }>;
     Draggable: () => Promise<{
         new (target: gsap.DOMTarget, vars?: Draggable.Vars): {
             readonly autoScroll: number;
@@ -55,26 +195,7 @@ export declare const gsapPlugins: {
         hitTest(testObject1: Draggable.TestObject, testObject2: Draggable.TestObject, threshold?: number | string): boolean;
         timeSinceDrag(): number;
     }>;
-    EaselPlugin: () => Promise<gsap.plugins.EaselPlugin>;
-    Flip: () => Promise<{
-        new (): {};
-        readonly version: string;
-        batch(id?: string): FlipBatch;
-        convertCoordinates(fromElement: Element, toElement: Element): gsap.plugins.Matrix2D;
-        convertCoordinates(fromElement: Element, toElement: Element, point: gsap.Point2D): gsap.Point2D;
-        fit(fromElement: gsap.DOMTarget, toElement: gsap.DOMTarget | Flip.FlipState, vars?: Flip.FitVars): gsap.core.Tween | object | null;
-        from(state: Flip.FlipState, vars?: Flip.FromToVars): gsap.core.Timeline;
-        getState(targets: gsap.DOMTarget, vars?: Flip.FlipStateVars | string): Flip.FlipState;
-        getByTarget(target: Element | string): gsap.core.Timeline | null;
-        isFlipping(target: gsap.DOMTarget): boolean;
-        killFlipsOf(targets: gsap.DOMTarget, complete?: boolean): void;
-        makeAbsolute(targets: gsap.DOMTarget | Flip.FlipState[]): Element[];
-        to(state: Flip.FlipState, vars?: Flip.FromToVars): gsap.core.Timeline;
-        register(core: typeof gsap): void;
-        ElementState: typeof Flip.ElementState;
-        FlipState: typeof Flip.FlipState;
-    }>;
-    MotionPathPlugin: () => Promise<gsap.plugins.MotionPathPlugin>;
+    InertiaPlugin: () => Promise<gsap.plugins.InertiaPlugin>;
     Observer: () => Promise<{
         new (): {
             readonly deltaX: number;
@@ -108,76 +229,45 @@ export declare const gsapPlugins: {
         getById(id: string): Observer | undefined;
     }>;
     PixiPlugin: () => Promise<gsap.plugins.PixiPlugin>;
-    ScrollToPlugin: () => Promise<{
-        new (): {};
-        config(vars: ScrollToPlugin.ConfigVars): void;
-        max(element: gsap.DOMTarget): number;
-        offset(element: gsap.DOMTarget, container?: gsap.DOMTarget): number;
+    EaselPlugin: () => Promise<gsap.plugins.EaselPlugin>;
+    Physics2DPlugin: () => Promise<gsap.plugins.Physics2DPlugin>;
+    PhysicsPropsPlugin: () => Promise<gsap.plugins.PhysicsPropsPlugin>;
+    GSDevTools: () => Promise<{
+        new (target: gsap.DOMTarget, vars?: GSDevTools.Vars): {
+            kill(): void;
+        };
+        create(vars?: GSDevTools.Vars): GSDevTools;
+        getById(id: string): GSDevTools | null;
     }>;
-    ScrollTrigger: () => Promise<{
-        new (vars: ScrollTrigger.StaticVars, animation?: gsap.core.Animation): {
-            readonly animation?: gsap.core.Animation | undefined;
-            readonly callbackAnimation?: gsap.core.Animation | undefined;
-            readonly direction: number;
-            readonly end: number;
-            readonly isActive: boolean;
-            readonly pin?: Element;
-            readonly progress: number;
-            readonly scroller: Element | Window;
-            readonly start: number;
-            readonly trigger?: Element;
-            readonly vars: ScrollTrigger.Vars;
-            disable(revert?: boolean, allowAnimation?: boolean): void;
-            enable(reset?: boolean, refresh?: boolean): void;
-            endAnimation(): void;
-            getTween(snap?: boolean): gsap.core.Tween;
-            getTrailing(name?: string | boolean | null): ScrollTrigger[];
-            getVelocity(): number;
-            kill(reset?: boolean, allowAnimation?: boolean): void;
-            labelToScroll(label: string): number;
-            next(): ScrollTrigger | undefined;
-            previous(): ScrollTrigger | undefined;
-            refresh(): void;
-            scroll(): number;
-            scroll(position: number): void;
-            tweenTo(position: number): gsap.core.Tween;
-            update(reset?: boolean, recordVelocity?: boolean, forceFake?: boolean): void;
+    CustomEase: () => Promise<{
+        new (id: string, data?: string | number[], config?: CustomEaseConfig): {
+            id: string;
+            ease: EaseFunction;
+            data: string | number[];
+            segment: number[];
+            setData(data?: string | number[], config?: CustomEaseConfig): /*elided*/ any;
+            getSVGData(config?: CustomEaseConfig): string;
         };
-        readonly version: string;
-        readonly isTouch: number;
-        addEventListener(event: "scrollStart" | "scrollEnd" | "refreshInit" | "refresh" | "matchMedia" | "revert", callback: gsap.Callback): void;
-        batch(targets: gsap.DOMTarget, vars: ScrollTrigger.BatchVars): ScrollTrigger[];
-        clearMatchMedia(name?: string): void;
-        clearScrollMemory(scrollRestoration?: string): void;
-        config(vars: ScrollTrigger.ConfigVars): void;
-        create(vars: ScrollTrigger.StaticVars): ScrollTrigger;
-        defaults(vars: ScrollTrigger.StaticVars): ScrollTrigger.StaticVars;
-        getAll(): ScrollTrigger[];
-        disable(reset?: boolean, kill?: boolean): void;
-        enable(): void;
-        getById(id: string): ScrollTrigger | undefined;
-        getScrollFunc(element: gsap.DOMTarget | Window, horizontal?: boolean): ScrollTrigger.ScrollFunc;
-        isInViewport(element: Element | string, ratio?: number, horizontal?: boolean): boolean;
-        isScrolling(): boolean;
-        killAll(allowListeners?: boolean): void;
-        matchMedia(vars: ScrollTrigger.MatchMediaObject): void;
-        maxScroll(target: HTMLElement | Window, horizontal?: boolean): number;
-        normalizeScroll(enable?: boolean | ScrollTrigger.NormalizeVars | Observer): Observer | undefined;
-        normalizeScroll(): Observer | undefined;
-        observe(vars: Observer.ObserverVars): Observer;
-        positionInViewport(element: Element | string, referencePoint?: string | number, horizontal?: boolean): number;
-        refresh(safe?: boolean): void;
-        register(core: typeof gsap): void;
-        removeEventListener(event: "scrollStart" | "scrollEnd" | "refreshInit" | "refresh" | "matchMedia", callback: gsap.Callback): void;
-        saveStyles(targets: gsap.DOMTarget): void;
-        scrollerProxy(scroller: gsap.DOMTarget, vars?: ScrollTrigger.ScrollerProxyVars): void;
-        snapDirectional(incrementOrArray: number | number[]): ScrollTrigger.SnapDirectionalFunc;
-        sort(func?: Function): ScrollTrigger[];
-        update(): void;
+        create(id: string, data?: string | number[], config?: CustomEaseConfig): EaseFunction;
+        register(core: object): void;
+        get(id: string): EaseFunction;
+        getSVGData(ease: CustomEase | EaseFunction | string, config?: CustomEaseConfig): string;
     }>;
-    TextPlugin: () => Promise<gsap.plugins.TextPlugin>;
     RoughEase: () => Promise<gsap.RoughEase>;
     ExpoScaleEase: () => Promise<gsap.ExpoScaleEase>;
     SlowMo: () => Promise<gsap.SlowMo>;
-    CustomEase: () => Promise<any>;
+    CustomBounce: () => Promise<{
+        new (id: string, vars?: CustomBounceVars): {
+            ease: EaseFunction;
+        };
+        create(id: string, vars?: CustomBounceVars): EaseFunction;
+        register(core: object): void;
+    }>;
+    CustomWiggle: () => Promise<{
+        new (id: string, vars?: CustomWiggleVars): {
+            ease: EaseFunction;
+        };
+        create(id: string, vars?: CustomWiggleVars): EaseFunction;
+        register(core: object): void;
+    }>;
 };

package/dist/runtime/gsap-plugins.js

@@ -1,18 +1,33 @@
-const gsapCorePlugins = {
-  Draggable: () => import("gsap/Draggable").then((mod) => mod.Draggable),
-  EaselPlugin: () => import("gsap/EaselPlugin").then((mod) => mod.EaselPlugin),
-  Flip: () => import("gsap/Flip").then((mod) => mod.Flip),
+export const gsapPlugins = {
+  // Scroll Plugins
+  ScrollTrigger: () => import("gsap/ScrollTrigger").then((mod) => mod.ScrollTrigger),
+  ScrollToPlugin: () => import("gsap/ScrollToPlugin").then((mod) => mod.ScrollToPlugin),
+  ScrollSmoother: () => import("gsap/ScrollSmoother").then((mod) => mod.ScrollSmoother),
+  // Text Plugins
+  SplitText: () => import("gsap/SplitText").then((mod) => mod.SplitText),
+  ScrambleTextPlugin: () => import("gsap/ScrambleTextPlugin").then((mod) => mod.ScrambleTextPlugin),
+  TextPlugin: () => import("gsap/TextPlugin").then((mod) => mod.TextPlugin),
+  // SVG Plugins
+  DrawSVGPlugin: () => import("gsap/DrawSVGPlugin").then((mod) => mod.DrawSVGPlugin),
+  MorphSVGPlugin: () => import("gsap/MorphSVGPlugin").then((mod) => mod.MorphSVGPlugin),
   MotionPathPlugin: () => import("gsap/MotionPathPlugin").then((mod) => mod.MotionPathPlugin),
+  MotionPathHelper: () => import("gsap/MotionPathHelper").then((mod) => mod.MotionPathHelper),
+  // UI Plugins
+  Flip: () => import("gsap/Flip").then((mod) => mod.Flip),
+  Draggable: () => import("gsap/Draggable").then((mod) => mod.Draggable),
+  InertiaPlugin: () => import("gsap/InertiaPlugin").then((mod) => mod.InertiaPlugin),
   Observer: () => import("gsap/Observer").then((mod) => mod.Observer),
+  // Other Plugins
   PixiPlugin: () => import("gsap/PixiPlugin").then((mod) => mod.PixiPlugin),
-  ScrollToPlugin: () => import("gsap/ScrollToPlugin").then((mod) => mod.ScrollToPlugin),
-  ScrollTrigger: () => import("gsap/ScrollTrigger").then((mod) => mod.ScrollTrigger),
-  TextPlugin: () => import("gsap/TextPlugin").then((mod) => mod.TextPlugin),
+  EaselPlugin: () => import("gsap/EaselPlugin").then((mod) => mod.EaselPlugin),
+  Physics2DPlugin: () => import("gsap/Physics2DPlugin").then((mod) => mod.Physics2DPlugin),
+  PhysicsPropsPlugin: () => import("gsap/PhysicsPropsPlugin").then((mod) => mod.PhysicsPropsPlugin),
+  GSDevTools: () => import("gsap/GSDevTools").then((mod) => mod.GSDevTools),
+  // Eases
+  CustomEase: () => import("gsap/CustomEase").then((mod) => mod.CustomEase),
   RoughEase: () => import("gsap/EasePack").then((mod) => mod.RoughEase),
   ExpoScaleEase: () => import("gsap/EasePack").then((mod) => mod.ExpoScaleEase),
   SlowMo: () => import("gsap/EasePack").then((mod) => mod.SlowMo),
-  CustomEase: () => import("gsap/CustomEase").then((mod) => mod.CustomEase)
-};
-export const gsapPlugins = {
-  ...gsapCorePlugins
+  CustomBounce: () => import("gsap/CustomBounce").then((mod) => mod.CustomBounce),
+  CustomWiggle: () => import("gsap/CustomWiggle").then((mod) => mod.CustomWiggle)
 };

package/dist/runtime/plugin.d.ts

@@ -1,5 +1,2 @@
-/**
- * Register GSAP plugins only if required in module options
- */
 declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugin.js

@@ -1,16 +1,37 @@
 import { gsap } from "gsap";
 import { gsapPlugins } from "./gsap-plugins.js";
 import { defineNuxtPlugin, useRuntimeConfig } from "#app";
-export default defineNuxtPlugin(async (_nuxtApp) => {
+export default defineNuxtPlugin(async (nuxtApp) => {
   const config = useRuntimeConfig().public.gsap;
-  const pluginsToRegister = config.plugins || [];
-  for (const pluginName of pluginsToRegister) {
-    if (gsapPlugins[pluginName]) {
-      const plugin = await gsapPlugins[pluginName]();
-      _nuxtApp.provide(pluginName, plugin);
+  const pluginsToRegister = new Set(config.plugins || []);
+  const pluginDependencies = {
+    ScrollSmoother: ["ScrollTrigger"],
+    CustomWiggle: ["CustomEase"],
+    CustomBounce: ["CustomEase"]
+  };
+  const resolvedPlugins = /* @__PURE__ */ new Set();
+  const resolvePlugin = (plugin) => {
+    if (resolvedPlugins.has(plugin)) return;
+    const deps = pluginDependencies[plugin] || [];
+    deps.forEach(resolvePlugin);
+    resolvedPlugins.add(plugin);
+  };
+  for (const plugin of pluginsToRegister) {
+    resolvePlugin(plugin);
+  }
+  for (const pluginName of resolvedPlugins) {
+    const loader = gsapPlugins[pluginName];
+    if (!loader) {
+      throw new Error(
+        `[gsap-nuxt-module] Plugin "${pluginName}" not found. Available plugins: ${Object.keys(gsapPlugins).join(", ")}`
+      );
+    }
+    try {
+      const plugin = await loader();
       gsap.registerPlugin(plugin);
-    } else {
-      throw new Error(`[gsap-nuxt-module] Plugin "${pluginName}" not found, available plugins: ${Object.keys(gsapPlugins).join(", ")}`);
+      nuxtApp.provide(pluginName, plugin);
+    } catch (err) {
+      console.error(`[gsap-nuxt-module] Failed to load plugin "${pluginName}":`, err);
     }
   }
 });

package/dist/types.d.mts

@@ -1 +1,3 @@
-export { type ModuleOptions, default } from './module.js'
+export { default } from './module.mjs'
+
+export { type GSAPPluginName, type ModuleOptions } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsap-nuxt-module",
-  "version": "1.1.1",
+  "version": "1.1.4",
   "description": "GSAP integration for Nuxt.",
   "repository": "LucaArgentieri/gsap-nuxt-module",
   "author": "Luca Argentieri",
@@ -13,13 +13,12 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/types.d.ts",
       "import": "./dist/module.mjs",
-      "require": "./dist/module.cjs"
+      "types": "./dist/types.d.mts"
     }
   },
-  "main": "./dist/module.cjs",
-  "types": "./dist/types.d.ts",
+  "main": "./dist/module.mjs",
+  "types": "./dist/types.d.mts",
   "files": [
     "dist"
   ],
@@ -36,19 +35,19 @@
   },
   "dependencies": {
     "@nuxt/kit": "^3.15.4",
-    "gsap": "^3.12.7"
+    "gsap": "^3.14.1"
   },
   "devDependencies": {
     "@nuxt/devtools": "^2.1.0",
     "@nuxt/eslint-config": "^1.1.0",
-    "@nuxt/module-builder": "^0.8.4",
+    "@nuxt/module-builder": "^1.0.1",
     "@nuxt/schema": "^3.15.4",
     "@nuxt/test-utils": "^3.17.0",
     "@types/node": "latest",
     "changelogen": "^0.6.0",
     "eslint": "^9.21.0",
     "nuxt": "^3.15.4",
-    "typescript": "~5.7.3",
+    "typescript": "^5.9.3",
     "vitest": "^3.0.7",
     "vue-tsc": "^2.2.4"
   }

package/dist/module.cjs

@@ -1,5 +0,0 @@
-module.exports = function(...args) {
-  return import('./module.mjs').then(m => m.default.call(this, ...args))
-}
-const _meta = module.exports.meta = require('./module.json')
-module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.ts

@@ -1,8 +0,0 @@
-import * as _nuxt_schema from '@nuxt/schema';
-
-interface ModuleOptions {
-    plugins?: ('Draggable' | 'EaselPlugin' | 'Flip' | 'MotionPathPlugin' | 'Observer' | 'PixiPlugin' | 'ScrollToPlugin' | 'ScrollTrigger' | 'TextPlugin' | 'RoughEase' | 'ExpoScaleEase' | 'SlowMo' | 'CustomEase')[];
-}
-declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
-
-export { type ModuleOptions, _default as default };

package/dist/runtime/composables/useCustomEase.d.ts

@@ -1 +0,0 @@
-export declare const useCustomEase: () => typeof CustomEase;

package/dist/runtime/composables/useCustomEase.js

@@ -1,8 +0,0 @@
-import { useNuxtApp } from "#app";
-export const useCustomEase = () => {
-  const { $CustomEase } = useNuxtApp();
-  if (!$CustomEase) {
-    throw new Error("[useCustomEase] CustomEase not registered! Did you enable it in nuxt.config.ts?");
-  }
-  return $CustomEase;
-};

package/dist/runtime/composables/useDraggable.d.ts

@@ -1 +0,0 @@
-export declare const useDraggable: () => typeof Draggable | undefined;

package/dist/runtime/composables/useDraggable.js

@@ -1,8 +0,0 @@
-import { useNuxtApp } from "#app";
-export const useDraggable = () => {
-  const { $Draggable } = useNuxtApp();
-  if (!$Draggable) {
-    throw new Error("[useDraggable] Draggable not registered! Did you enable it in nuxt.config.ts?");
-  }
-  return $Draggable;
-};

package/dist/runtime/composables/useFlip.d.ts

@@ -1 +0,0 @@
-export declare const useFlip: () => typeof Flip;

package/dist/runtime/composables/useFlip.js

@@ -1,8 +0,0 @@
-import { useNuxtApp } from "#app";
-export const useFlip = () => {
-  const { $Flip } = useNuxtApp();
-  if (!$Flip) {
-    throw new Error("[useFlip] Flip not registered! Did you enable it in nuxt.config.ts?");
-  }
-  return $Flip;
-};

package/dist/runtime/composables/useObserver.d.ts

@@ -1 +0,0 @@
-export declare const useObserver: () => typeof Observer;

package/dist/runtime/composables/useObserver.js

@@ -1,8 +0,0 @@
-import { useNuxtApp } from "#app";
-export const useObserver = () => {
-  const { $Observer } = useNuxtApp();
-  if (!$Observer) {
-    throw new Error("[useObserver] Observer not registered! Did you enable it in nuxt.config.ts?");
-  }
-  return $Observer;
-};

package/dist/runtime/composables/useScrollToPlugin.d.ts

@@ -1 +0,0 @@
-export declare const useScrollToPlugin: () => typeof ScrollToPlugin;

package/dist/runtime/composables/useScrollToPlugin.js

@@ -1,8 +0,0 @@
-import { useNuxtApp } from "#app";
-export const useScrollToPlugin = () => {
-  const { $ScrollToPlugin } = useNuxtApp();
-  if (!$ScrollToPlugin) {
-    throw new Error("[useScrollToPlugin] ScrollToPlugin not registered! Did you enable it in nuxt.config.ts?");
-  }
-  return $ScrollToPlugin;
-};

package/dist/runtime/composables/useScrollTrigger.d.ts

@@ -1 +0,0 @@
-export declare const useScrollTrigger: () => typeof ScrollTrigger;

package/dist/runtime/composables/useScrollTrigger.js

@@ -1,8 +0,0 @@
-import { useNuxtApp } from "#app";
-export const useScrollTrigger = () => {
-  const { $ScrollTrigger } = useNuxtApp();
-  if (!$ScrollTrigger) {
-    throw new Error("[useScrollTrigger] ScrollTrigger not registered! Did you enable it in nuxt.config.ts?");
-  }
-  return $ScrollTrigger;
-};

package/dist/types.d.ts

@@ -1 +0,0 @@
-export { type ModuleOptions, default } from './module'