reacthub-pixitweenjs 0.3.0-alpha.3 → 0.3.0-alpha.5

package/dist/components/PixiCaptionsTrack/useCaptionStyles.d.ts

@@ -0,0 +1,45 @@
+import { CaptionRenderMode, CaptionSegment } from '../../utils/captions';
+import * as PIXI from "pixi.js";
+export interface CaptionStyleInput {
+    fontFamily: string;
+    fontWeight: string | number;
+    fontSize: number;
+    fill: string;
+    align: string;
+    wordWrapWidth: number;
+    padding: number;
+    stroke: string | number | null;
+    strokeWidth: number;
+    dropShadow: boolean;
+    dropShadowColor: string | number;
+    dropShadowBlur: number;
+    dropShadowAlpha: number;
+    dropShadowAngle: number;
+    dropShadowDistance: number;
+    highlightColor: string;
+}
+/**
+ * Every TextStyle and filter the caption modes draw with.
+ *
+ * Fonts usually arrive after the first draw. Pixi caches font metrics per font string and keeps
+ * the fallback-font texture, so on `FONTS_LOADED` (via `useFontEpoch`) the metrics cache is
+ * flushed and the styles are rebuilt. Filters are destroyed when replaced and on unmount
+ * (Clippy leaked them).
+ *
+ * NOTE: `trim` is deliberately NOT set. In v8 trim shrinks the rendered texture, so an
+ * `anchor: 0.5` pivots on a trimmed size that varies per word (ascenders, descenders, shadow
+ * bleed) and words float at different baselines.
+ */
+export declare function useCaptionStyles(input: CaptionStyleInput, mode: CaptionRenderMode, segments: ReadonlyArray<CaptionSegment>): {
+    base: PIXI.TextStyle;
+    active: PIXI.TextStyle;
+    inactive: PIXI.TextStyle;
+    colour: Record<string, PIXI.TextStyle>;
+    vhs: {
+        cyan: PIXI.TextStyle;
+        magenta: PIXI.TextStyle;
+    } | null;
+    glowPopBlur: PIXI.BlurFilter;
+    springPopBlur: PIXI.BlurFilter;
+    bloomBlur: PIXI.BlurFilter;
+};

package/dist/components/PixiCaptionsTrack/useEmojiTextures.d.ts

@@ -0,0 +1,8 @@
+import { CaptionSegment } from '../../utils/captions';
+import * as PIXI from "pixi.js";
+/**
+ * Textures for the emoji drawn above words in glow-pop. They come from the pinned Noto PNGs (or
+ * a word's own `emojiSrc`), not a system emoji font, so the editor and a server render draw the
+ * same glyph. Textures belong to Pixi's Assets cache and are not destroyed here.
+ */
+export declare function useEmojiTextures(segments: ReadonlyArray<CaptionSegment>, enabled: boolean): Record<string, PIXI.Texture>;

package/dist/components/PixiImageSprite/PixiImageSprite.d.ts

@@ -9,7 +9,24 @@ type PixiImageSpriteProps = PixiBaseSpriteProps & {
             isDragging?: boolean;
         } | null;
     };
+    /** Cleared when the sprite unmounts, so a host's hover state never points at a dead node. */
+    mouseOverSpriteRef?: {
+        current?: unknown;
+    };
 };
+/**
+ * PixiImageSprite — an image on the Pixi canvas.
+ *
+ * Uplifted from the Clippy editor:
+ *  - `src` is sanitised (a CDN origin wrongly prepended to a data: URI is stripped)
+ *  - extensionless URLs load (forced texture parser)
+ *  - the texture is cleared on `src` change / error / unmount instead of leaving a stale image
+ *  - the cancel race is gone (the load handle is created synchronously)
+ *  - width/height of 0 fall back to the texture's native size
+ *  - `crop`, `effects: {name, intensity, params}`, `neonColor` and `plateKey` are supported,
+ *    and `blendMode` goes through `useSpriteFilters` (a raw sprite blendMode is ignored in
+ *    Pixi v8 once the sprite has filters)
+ */
 declare const PixiImageSpriteInner: ({ ref, ...props }: PixiImageSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/components/PixiSVGSprite/PixiSvgImageSprite.d.ts

@@ -0,0 +1,35 @@
+import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiSvgImageSpriteProps extends PixiBaseSpriteProps {
+    /** SVG URL, `data:image/svg+xml` URI, or any raster image URL. */
+    src: string;
+    transformation: PixiBaseSpriteProps["transformation"] & {
+        /** Tint colour (any CSS colour). Applied live, with no re-rasterisation. */
+        color?: string;
+        /** Alias for `color`. */
+        fill?: string;
+        stroke?: string;
+        /** Alias for `stroke` (used by templates). */
+        strokeColor?: string;
+        strokeWidth?: number;
+    };
+    mouseOverSpriteRef?: {
+        current?: unknown;
+    };
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+/**
+ * PixiSvgImageSprite — a TINTABLE svg: art drawn in white (e.g. an icon set) is rasterised
+ * once at `width x height x resolution` and recoloured with a sprite tint, so changing the
+ * colour never re-rasterises. Ported from the Clippy editor.
+ *
+ * The sprite stays mounted with `Texture.EMPTY` + alpha 0 until the raster is ready, so the
+ * transformer keeps a stable node and there is no remount flash on load or recolour.
+ * Resizing re-rasterises once, after the drag settles (see useSvgTexture).
+ */
+declare const PixiSvgImageSpriteInner: ({ ref, ...props }: PixiSvgImageSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiSvgImageSprite: typeof PixiSvgImageSpriteInner;
+export default PixiSvgImageSprite;

package/dist/components/PixiSVGSprite/PixiSvgPathSprite.d.ts

@@ -5,8 +5,11 @@ import * as React from "react";
 import * as PIXI from "pixi.js";
 export interface PixiSvgPathSpriteProps extends PixiBaseSpriteProps {
     uniqueId: string;
+    /** A single path `d` attribute. */
     path?: string;
+    /** Raw SVG markup. Overrides `path`. */
     svg?: string;
+    /** SVG URL / data URI. Rendered through the multi-colour svg pipeline (`PixiSvgRawSprite`). */
     startAt: number;
     endAt: number;
     transformation: {
@@ -67,6 +70,13 @@ export interface PixiSvgPathSpriteProps extends PixiBaseSpriteProps {
     onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
 }
+/**
+ * `src` -> delegate to PixiSvgRawSprite (fetch + bake with the original viewBox).
+ * `path` / `svg` -> inline geometry, baked here.
+ *
+ * Kept as one public component because the AEP router and existing stories pass any of the
+ * three. The split is a thin switch so each branch keeps its own hooks.
+ */
 declare const PixiSvgPathSprite: ({ ref, ...props }: PixiSvgPathSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/components/PixiSVGSprite/PixiSvgRawSprite.d.ts

@@ -0,0 +1,30 @@
+import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiSvgRawSpriteProps extends PixiBaseSpriteProps {
+    src: string;
+    transformation: PixiBaseSpriteProps["transformation"] & {
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+    mouseOverSpriteRef?: {
+        current?: unknown;
+    };
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+/**
+ * PixiSvgRawSprite — an svg that is NOT tintable (multi-colour art). Fill/stroke overrides
+ * are written onto the SVG root and the document is baked through `Graphics.svg()` into a
+ * texture. Paths that inherit fill/stroke pick the override up; per-path fills and gradients
+ * are left alone. For gradient-faithful backgrounds use a plain image/svg URL instead.
+ *
+ * Ported from the Clippy editor. Fixes: the original viewBox is preserved (Clippy forced
+ * `0 0 w h`, distorting non-square art), the baked texture AND the throwaway Graphics are
+ * always destroyed, and resizes are debounced.
+ */
+declare const PixiSvgRawSpriteInner: ({ ref, ...props }: PixiSvgRawSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiSvgRawSprite: typeof PixiSvgRawSpriteInner;
+export default PixiSvgRawSprite;

package/dist/components/PixiSVGSprite/index.d.ts

@@ -1,2 +1,6 @@
 export { default as PixiSvgPathSprite } from './PixiSvgPathSprite';
+export { default as PixiSvgImageSprite } from './PixiSvgImageSprite';
+export type { PixiSvgImageSpriteProps } from './PixiSvgImageSprite';
+export { default as PixiSvgRawSprite } from './PixiSvgRawSprite';
+export type { PixiSvgRawSpriteProps } from './PixiSvgRawSprite';
 export { default as PixiMorphSvgSprite } from './PixiMorphSvgSprite';

package/dist/components/PixiSequence/PixiSequence.d.ts

@@ -1,11 +1,35 @@
-import * as React from "react";
+import { default as React } from 'react';
 export interface PixiSequenceProps {
-    children: React.ReactNode;
+    children?: React.ReactNode;
     /** start time of the sequence in seconds */
-    startAt: number;
+    startAt?: number;
     /** end time of the sequence in seconds */
-    endAt: number;
+    endAt?: number;
     /** unique id */
     uniqueId?: string;
+    /** Hide the element on exit (used with hideStart/hideEnd for transition hand-offs). */
+    hideOnExit?: boolean;
+    hideOnEntry?: boolean;
+    /** Seconds. Clamped to the sequence bounds. */
+    hideStart?: number;
+    hideEnd?: number;
+    zIndex?: number;
+    /**
+     * Entrance overlap (crossfade at hard cuts), stamped by `applyEntranceOverlaps`.
+     * The visibility window opens this many seconds before `startAt`.
+     */
+    entranceOverlapSec?: number;
 }
-export declare const PixiSequence: (props: PixiSequenceProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * PixiSequence - Unified timeline with alpha-based visibility control
+ *
+ * Props:
+ * - startAt: Sequence start time
+ * - endAt: Sequence end time
+ * - uniqueId: Unique identifier
+ * - hideOnExit: Boolean flag for exit hiding
+ * - hideOnEntry: Boolean flag for entry hiding
+ * - hideStart: Start time to hide (will be clamped to sequence bounds)
+ * - hideEnd: End time to hide (will be clamped to sequence bounds)
+ */
+export declare const PixiSequence: ({ children, startAt, endAt, uniqueId, hideOnExit, hideOnEntry, hideStart, hideEnd, zIndex, entranceOverlapSec, }: PixiSequenceProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/PixiTextSprite/PixiTextSplit.d.ts

@@ -21,6 +21,6 @@ export declare class TextStyleCache {
     get(key: string, build: () => PIXI.TextStyle): PIXI.TextStyle;
     get hitRate(): number;
 }
-export declare function _textSplitStyleKey(glyph: AepTextLayoutGlyph, color: string): string;
+export declare function _textSplitStyleKey(glyph: AepTextLayoutGlyph, color: string, styleSig?: string): string;
 export declare const PixiTextSplit: React.FC<PixiTextSplitProps>;
 export {};

package/dist/components/PixiTextSprite/PixiTextSprite.d.ts

@@ -44,8 +44,27 @@ export interface PixiTextSpriteProps extends Omit<PixiBaseSpriteProps, "transfor
         blurEnabled?: boolean;
         blurRadius?: number;
         fill: string | number;
+        /** Two or more colours -> linear gradient fill (overrides `fill`). */
+        gradientColors?: (string | number)[];
+        gradientStops?: number[];
+        /** 0 = vertical (default), 1 = horizontal. */
+        gradientType?: 0 | 1;
         stroke?: string | number;
+        /** v8 name; `strokeThickness` (v7) is still accepted. */
+        strokeWidth?: number;
         strokeThickness?: number;
+        dropShadowAlpha?: number;
+        /** Radians. */
+        dropShadowAngle?: number;
+        dropShadowDistance?: number;
+        /**
+         * `"box"` (default) keeps the legacy behaviour: the background fills the sprite's
+         * `width x height`. `"hug"` sizes it to the measured text plus `backgroundPadding`.
+         */
+        backgroundFit?: "box" | "hug";
+        backgroundPadding?: number;
+        /** Background corner radius, px. */
+        backgroundRadius?: number;
         zIndex?: number;
         align?: string;
         textBaseline?: string;
@@ -78,6 +97,12 @@ export interface PixiTextSpriteProps extends Omit<PixiBaseSpriteProps, "transfor
             scaleInput?: number;
         };
         effect?: Effects;
+        effects?: {
+            name?: Effects | string;
+            intensity?: number;
+            params?: Record<string, unknown>;
+        };
+        neonColor?: number | string | null;
     };
     pointerdown?: () => void;
     pointerup?: () => void;

package/dist/components/PixiThreeSprite/PixiThreeModelSprite.d.ts

@@ -0,0 +1,23 @@
+import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import { ThreeDParams } from '../../utils/threeModel';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiThreeModelSpriteProps extends PixiBaseSpriteProps {
+    uniqueId: string;
+    /** GLB/GLTF URL. Omit for the procedural torus-knot. */
+    src?: string;
+    /** Relative path -> absolute URL map for glTF sidecar textures/buffers. */
+    resources?: Record<string, string>;
+    startAt: number;
+    endAt: number;
+    threeD?: ThreeDParams;
+    locked?: boolean;
+    pointerdown?: () => void;
+    applyTransformer?: boolean;
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+export declare const PixiThreeModelSprite: React.MemoExoticComponent<({ ref, ...props }: PixiThreeModelSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element>;
+export default PixiThreeModelSprite;

package/dist/components/PixiThreeSprite/index.d.ts

@@ -1,2 +1,4 @@
 export { PixiThreeSprite } from './PixiThreeSprite';
 export type { PixiThreeSpriteProps } from './PixiThreeSprite';
+export { PixiThreeModelSprite } from './PixiThreeModelSprite';
+export type { PixiThreeModelSpriteProps } from './PixiThreeModelSprite';

package/dist/components/PixiVideoSprite/PixiVideoSprite.d.ts

@@ -4,9 +4,18 @@ import * as PIXI from "pixi.js";
 export interface PixiVideoSpriteProps extends PixiBaseSpriteProps {
     uniqueId: string;
     src: string;
+    /** Source in-point in seconds (where in the file this clip starts). */
     frameStartAt: number;
+    /**
+     * Source out-point in seconds. Kept for API compatibility; the clip length on
+     * the timeline is `endAt - startAt`, which is what drives playback.
+     */
     frameEndAt: number;
     mute: boolean;
+    /** 0..1. Applied to the underlying element. Default 1. */
+    volume?: number;
+    /** Playback rate applied to the element (audio clock). Default 1. */
+    speed?: number;
     locked: boolean;
     pointerdown?: () => void;
     pointerup?: () => void;
@@ -17,10 +26,27 @@ export interface PixiVideoSpriteProps extends PixiBaseSpriteProps {
     mouseout?: () => void;
     applyTransformer?: boolean;
     onAnchorTransformationEnd?: (endData: any) => void;
+    /** Accepted for API compatibility. Frames are pulled by the timeline, not a ticker. */
     fps?: number;
     onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
 }
+/**
+ * PixiVideoSprite — video on the Pixi v8 canvas, driven by the master GSAP
+ * timeline (scrub model, ported from the Clippy editor).
+ *
+ *   useVideoTexture       Assets.load (mp4/webm) or a manual <video> fallback
+ *                         (.mov/.avi...). Ref-counted per URL, 5s load timeout.
+ *   useVideoLifecycle     waiting/stalled state, muted + playbackRate sync.
+ *   useVideoTimelineSync  GSAP dummy tween maps timeline time -> currentTime and
+ *                         calls source.update(). Never play()s while scrubbing,
+ *                         which keeps the browser's concurrent hardware-decode
+ *                         cap (~2-4 videos) from blacking clips out. During real
+ *                         playback (Events.RESUME) the active clip is play()'d so
+ *                         audio is audible.
+ *
+ * Trimming `frameStartAt` does NOT reload the texture (it is read through a ref).
+ */
 declare const PixiVideoSprite: ({ ref, ...props }: PixiVideoSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/components/index.d.ts

@@ -2,7 +2,9 @@ export * from './PixiImageSprite';
 export * from './PixiSVGSprite';
 export * from './PixiAudioSprite';
 export * from './PixiGifSprite';
+export * from './PixiThreeSprite';
 export * from './PixiTextSprite';
+export * from './PixiCaptionsTrack';
 export * from './PixiVideoSprite';
 export * from './PixiAnimatedSprite';
 export * from './PixiSequence';

package/dist/constants/animation.d.ts

@@ -0,0 +1,232 @@
+/**
+ * Animation System Constants
+ *
+ * UPPER_SNAKE_CASE names match GSAP effect names in utils/gsapEffects.
+ * Use these values for transformation.animationIn.name / animationOut.name.
+ */
+export declare const ANIMATION_TIMING: {
+    /** Default animation duration in milliseconds */
+    DEFAULT_DURATION_MS: number;
+    /** Default animation duration in seconds */
+    DEFAULT_DURATION_SEC: number;
+    /** Minimum animation duration in seconds */
+    MIN_DURATION_SEC: number;
+    /** Maximum animation duration in seconds */
+    MAX_DURATION_SEC: number;
+    /**
+     * Entrance overlap at hard cuts (seconds). When element B starts exactly
+     * where element A ends AND A has an animationOut AND B has an animationIn,
+     * B's entrance begins this long BEFORE B.start so the cut crossfades
+     * instead of blinking through a near-black frame (A faded to 0 + B still
+     * at scale 0). Clamped per element to its animationIn duration and length.
+     * Must match the nodejs renderer (ENTRANCE_OVERLAP_SEC) frame-exactly.
+     */
+    ENTRANCE_OVERLAP_SEC: number;
+    /** Default speed for loop animations (e.g. SPIN_360), in full rotations per second.
+     *  0.25 = one full turn every 4s — a slow, product-turntable-style spin. */
+    DEFAULT_LOOP_ROTATIONS_PER_SEC: number; /** Loop animation speed bounds, in rotations per second. */
+    MIN_LOOP_ROTATIONS_PER_SEC: number;
+    MAX_LOOP_ROTATIONS_PER_SEC: number;
+};
+export declare const CANVAS_DEFAULTS: {
+    WIDTH: number;
+    HEIGHT: number;
+};
+export declare const ANIMATIONS_WITHOUT_ALPHA: Set<string>;
+export declare const SPECIAL_ANIMATIONS: Set<string>;
+export declare const LOOP_ANIMATIONS: Set<string>;
+/**
+ * Check if an animation name is a continuous loop animation (as opposed to
+ * an entrance/exit gsap.effects animation).
+ * @param {string} animationName
+ * @returns {boolean}
+ */
+export declare function isLoopAnimation(animationName: any): boolean;
+export declare const ANIMATION: {
+    NONE: string;
+    BOUNCE: string;
+    FLASH: string;
+    PULSE: string;
+    RUBBER_BAND: string;
+    SHAKE_X: string;
+    SHAKE_Y: string;
+    HEAD_SHAKE: string;
+    SWING: string;
+    TADA: string;
+    WOBBLE: string;
+    JELLO: string;
+    HEART_BEAT: string;
+    BACK_IN_DOWN: string;
+    BACK_IN_LEFT: string;
+    BACK_IN_RIGHT: string;
+    BACK_IN_UP: string;
+    BACK_OUT_DOWN: string;
+    BACK_OUT_LEFT: string;
+    BACK_OUT_RIGHT: string;
+    BACK_OUT_UP: string;
+    BOUNCE_IN: string;
+    BOUNCE_IN_DOWN: string;
+    BOUNCE_IN_LEFT: string;
+    BOUNCE_IN_RIGHT: string;
+    BOUNCE_IN_UP: string;
+    BOUNCE_OUT: string;
+    BOUNCE_OUT_DOWN: string;
+    BOUNCE_OUT_LEFT: string;
+    BOUNCE_OUT_RIGHT: string;
+    BOUNCE_OUT_UP: string;
+    FADE_IN: string;
+    FADE_IN_DOWN: string;
+    FADE_IN_DOWN_BIG: string;
+    FADE_IN_LEFT: string;
+    FADE_IN_LEFT_BIG: string;
+    FADE_IN_RIGHT: string;
+    FADE_IN_RIGHT_BIG: string;
+    FADE_IN_UP: string;
+    FADE_IN_UP_BIG: string;
+    FADE_IN_TOP_LEFT: string;
+    FADE_IN_TOP_RIGHT: string;
+    FADE_IN_BOTTOM_LEFT: string;
+    FADE_IN_BOTTOM_RIGHT: string;
+    FADE_OUT: string;
+    FADE_OUT_DOWN: string;
+    FADE_OUT_DOWN_BIG: string;
+    FADE_OUT_LEFT: string;
+    FADE_OUT_LEFT_BIG: string;
+    FADE_OUT_RIGHT: string;
+    FADE_OUT_RIGHT_BIG: string;
+    FADE_OUT_UP: string;
+    FADE_OUT_UP_BIG: string;
+    FADE_OUT_TOP_LEFT: string;
+    FADE_OUT_TOP_RIGHT: string;
+    FADE_OUT_BOTTOM_RIGHT: string;
+    FADE_OUT_BOTTOM_LEFT: string;
+    FLIP: string;
+    FLIP_IN_X: string;
+    FLIP_IN_Y: string;
+    FLIP_OUT_X: string;
+    FLIP_OUT_Y: string;
+    LIGHT_SPEED_IN_RIGHT: string;
+    LIGHT_SPEED_IN_LEFT: string;
+    LIGHT_SPEED_OUT_RIGHT: string;
+    LIGHT_SPEED_OUT_LEFT: string;
+    ROTATE_IN: string;
+    ROTATE_IN_DOWN_LEFT: string;
+    ROTATE_IN_DOWN_RIGHT: string;
+    ROTATE_IN_UP_LEFT: string;
+    ROTATE_IN_UP_RIGHT: string;
+    ROTATE_OUT: string;
+    ROTATE_OUT_DOWN_LEFT: string;
+    ROTATE_OUT_DOWN_RIGHT: string;
+    ROTATE_OUT_UP_LEFT: string;
+    ROTATE_OUT_UP_RIGHT: string;
+    HINGE: string;
+    JACK_IN_THE_BOX: string;
+    ROLL_IN: string;
+    ROLL_OUT: string;
+    ZOOM_IN: string;
+    ZOOM_IN_DOWN: string;
+    ZOOM_IN_LEFT: string;
+    ZOOM_IN_RIGHT: string;
+    ZOOM_IN_UP: string;
+    ZOOM_OUT: string;
+    ZOOM_OUT_DOWN: string;
+    ZOOM_OUT_LEFT: string;
+    ZOOM_OUT_RIGHT: string;
+    ZOOM_OUT_UP: string;
+    SLIDE_IN_DOWN: string;
+    SLIDE_IN_LEFT: string;
+    SLIDE_IN_RIGHT: string;
+    SLIDE_IN_UP: string;
+    SLIDE_OUT_DOWN: string;
+    SLIDE_OUT_LEFT: string;
+    SLIDE_OUT_RIGHT: string;
+    SLIDE_OUT_UP: string;
+    SPIN_360: string;
+    SCALE_POP: string;
+    WIPE_LEFT_RIGHT: string;
+    WIPE_RADIAL: string;
+    MASK_PAINT_ON: string;
+    TYPEWRITER: string;
+    RISE: string;
+    STAGGER_FADE_UP_TEXT: string;
+    STAGGER_FADE_TEXT: string;
+    STAGGER_FADE_UP: string;
+    STAGGER_FADE: string;
+    TEXT_CASCADE: string;
+    TEXT_SPOTLIGHT: string;
+    TEXT_BLINDS: string;
+    TEXT_POPCORN: string;
+    TEXT_RIPPLE: string;
+    TEXT_SHUFFLE: string;
+    TEXT_DOMINO: string;
+    TEXT_PENDULUM: string;
+    TEXT_SLIDE_REVEAL: string;
+    TEXT_SLOT: string;
+    TEXT_CURTAIN: string;
+    LIGHT_SPEED_IN: string;
+    LIGHT_SPEED_OUT: string;
+    ROATATE_IN_DOWN_LEFT: string;
+    ROATATE_IN_DOWN_RIGHT: string;
+    ROATATE_IN_UP_LEFT: string;
+    ROATATE_IN_UP_RIGHT: string;
+};
+/**
+ * Convert a camelCase animation name to UPPER_SNAKE_CASE.
+ * Uses explicit map first, then regex fallback.
+ * Already-UPPER_SNAKE_CASE names pass through unchanged.
+ *
+ * @param {string} name - Animation name in any format
+ * @returns {string} UPPER_SNAKE_CASE animation name
+ */
+export declare function camelToUpperSnake(name: any): any;
+/**
+ * Normalize animation config from various input formats.
+ * @param {string|object|null} anim - Animation name or config object
+ * @returns {{ name: string, durationSec: number }}
+ */
+interface AnimationConfig {
+    name?: string;
+    duration?: number;
+}
+interface NormalizedAnimation {
+    name: string;
+    durationSec: number;
+}
+export declare function normalizeAnimation(anim: string | AnimationConfig | null | undefined): NormalizedAnimation;
+interface LoopAnimationConfig {
+    name?: string;
+    rotationsPerSecond?: number;
+    direction?: 1 | -1;
+}
+interface NormalizedLoopAnimation {
+    name: string;
+    rotationsPerSecond: number;
+    direction: 1 | -1;
+}
+/**
+ * Normalize a loop-animation config from various input formats.
+ * Mirrors normalizeAnimation() but for `transformation.animationLoop`
+ * (continuous animations — see LOOP_ANIMATIONS).
+ * @param {string|object|null} anim - Loop animation name or config object
+ * @returns {{ name: string, rotationsPerSecond: number, direction: 1|-1 }}
+ */
+export declare function normalizeLoopAnimation(anim: string | LoopAnimationConfig | null | undefined): NormalizedLoopAnimation;
+/**
+ * Check if an animation affects the alpha/opacity of the target.
+ * @param {string} animationName - The animation name
+ * @returns {boolean}
+ */
+export declare function animationAffectsAlpha(animationName: string): boolean;
+/**
+ * Check if an animation requires special handling.
+ * @param {string} animationName - The animation name
+ * @returns {boolean}
+ */
+export declare function isSpecialAnimation(animationName: string): boolean;
+/**
+ * Check if an animation name is valid (exists as GSAP effect).
+ * @param {string} animationName - The animation name
+ * @returns {boolean}
+ */
+export declare function isValidAnimation(animationName: string): boolean;
+export {};