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

package/dist/components/AepComposition/AepPrecompRenderContext.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+import * as THREE from "three";
+import type * as PIXI from "pixi.js";
+interface PrecompTextureEntry {
+    canvas: HTMLCanvasElement | null;
+    texture: THREE.Texture | null;
+    width: number;
+    height: number;
+    rev: number;
+}
+interface PrecompRenderStore {
+    entries: Map<string, PrecompTextureEntry>;
+    subscribers: Set<() => void>;
+}
+export declare const AepPrecompRenderProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare function useAepPrecompStore(): PrecompRenderStore | null;
+export declare function registerPrecompTexture(store: PrecompRenderStore | null, layerId: string, width: number, height: number): PrecompTextureEntry | null;
+export declare function unregisterPrecompTexture(store: PrecompRenderStore | null, layerId: string): void;
+export declare function writePrecompFrame(store: PrecompRenderStore | null, layerId: string, app: PIXI.Application, rt: PIXI.RenderTexture): void;
+export declare function usePrecompTexture(layerId: string): PrecompTextureEntry | null;
+export {};

package/dist/components/AepComposition/AepPrecompRenderer.d.ts

@@ -0,0 +1,8 @@
+import { AepLayer } from '../../types/aep';
+import * as React from "react";
+export interface AepPrecompRendererProps {
+    layer: AepLayer & {
+        kind: "precomp";
+    };
+}
+export declare const AepPrecompRenderer: React.FC<AepPrecompRendererProps>;

package/dist/components/AepComposition/AepTextOverrideContext.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+export type AepTextOverrideMap = Record<string, string>;
+export declare const AepTextOverrideProvider: React.FC<{
+    value: AepTextOverrideMap | undefined;
+    children: React.ReactNode;
+}>;
+export declare function useAepTextOverride(layerId: string): string | undefined;
+export declare function resolveTextSource(layerId: string, authoredSource: string, overrides: AepTextOverrideMap | undefined): string;

package/dist/components/AepComposition/AepThemeContext.d.ts

@@ -0,0 +1,8 @@
+import { AepThemeMap } from '../../types/aep';
+import * as React from "react";
+export declare const AepThemeProvider: React.FC<{
+    value: AepThemeMap | undefined;
+    children: React.ReactNode;
+}>;
+export declare function useAepTheme(): AepThemeMap | undefined;
+export declare function mergeTheme(base: AepThemeMap | undefined, override: AepThemeMap | undefined): AepThemeMap | undefined;

package/dist/components/AepComposition/composeTransform3D.d.ts

@@ -0,0 +1,27 @@
+export interface Transform3DChannels {
+    x: number;
+    y: number;
+    z: number;
+    rx: number;
+    ry: number;
+    rz: number;
+    sx: number;
+    sy: number;
+    sz: number;
+    alpha: number;
+}
+export declare const IDENTITY_TRANSFORM_3D: Transform3DChannels;
+export declare function rotateVec3Euler(v: {
+    x: number;
+    y: number;
+    z: number;
+}, eulerDeg: {
+    rx: number;
+    ry: number;
+    rz: number;
+}): {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare function composeTransform3D(parent: Transform3DChannels, child: Transform3DChannels): Transform3DChannels;

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

@@ -0,0 +1,39 @@
+export { AepComposition } from './AepComposition';
+export type { AepCompositionProps } from './AepComposition';
+export { AepLayerProvider, useAepLayerContext, useAepLayerContextOptional, AepRecursionDepthProvider, useAepRecursionDepth, AEP_MAX_PRECOMP_DEPTH, mergeAssetMaps, } from './AepLayerProvider';
+export type { AepLayerContextValue, AepAssetOverrideMap, AepAssetOverride, } from './AepLayerProvider';
+export { AepLayerRouter } from './AepLayerRouter';
+export { Aep3DScene } from './Aep3DScene';
+export type { Aep3DSceneProps } from './Aep3DScene';
+export { Aep3DPostFx } from './Aep3DPostFx';
+export type { Aep3DPostFxProps } from './Aep3DPostFx';
+export { usePixiRenderTexture } from './usePixiRenderTexture';
+export { threeTextureFromPixi } from './threeTextureFromPixi';
+export type { ThreeTextureBridge } from './threeTextureFromPixi';
+export { Aep3DShapeMesh } from './Aep3DShapeMesh';
+export type { Aep3DShapeMeshProps } from './Aep3DShapeMesh';
+export { Aep3DTextMesh } from './Aep3DTextMesh';
+export type { Aep3DTextMeshProps } from './Aep3DTextMesh';
+export { AepMsdfTextMesh } from './AepMsdfTextMesh';
+export type { AepMsdfTextMeshProps } from './AepMsdfTextMesh';
+export { MsdfAtlasProvider, MsdfAtlasRegistry, useMsdfAtlas, type MsdfAtlasRegistryValue, } from './msdfAtlasRegistry';
+export { pathToThreeShape, pathHash } from './pathToThreeShape';
+export { AepPrecompRenderProvider, useAepPrecompStore, usePrecompTexture, } from './AepPrecompRenderContext';
+export { AepPrecompRenderer } from './AepPrecompRenderer';
+export type { AepPrecompRendererProps } from './AepPrecompRenderer';
+export { Aep3DPrecompPlane } from './Aep3DPrecompPlane';
+export type { Aep3DPrecompPlaneProps } from './Aep3DPrecompPlane';
+export { useAepLayerTransform3D } from './useAepLayerTransform3D';
+export type { AepResolvedTransform3D } from './useAepLayerTransform3D';
+export { composeTransform3D, rotateVec3Euler, IDENTITY_TRANSFORM_3D, } from './composeTransform3D';
+export type { Transform3DChannels } from './composeTransform3D';
+export { useAepLayerTransform } from './useAepLayerTransform';
+export type { AepResolvedTransform } from './useAepLayerTransform';
+export { AepAssetResolverProvider, defaultAssetResolver, useAepAssetResolver, type AepAssetResolver, type AepResolvedAsset, } from './AepAssetResolver';
+export { useResolveAsset } from './useResolveAsset';
+export type { AepAssetState, AepResolvedAssetState } from './useResolveAsset';
+export { AepThemeProvider, useAepTheme, mergeTheme, } from './AepThemeContext';
+export { AepTextOverrideProvider, useAepTextOverride, resolveTextSource, } from './AepTextOverrideContext';
+export type { AepTextOverrideMap } from './AepTextOverrideContext';
+export { resolvePostFxList } from './resolvePostFxList';
+export { shouldSplitText } from './shouldSplitText';

package/dist/components/AepComposition/matteSourceIds.d.ts

@@ -0,0 +1,2 @@
+import { AepLayer } from '../../types/aep';
+export declare function collectMatteSourceIds(layers: ReadonlyArray<AepLayer>): Set<string>;

package/dist/components/AepComposition/msdfAtlasRegistry.d.ts

@@ -0,0 +1,16 @@
+import { MsdfAtlas } from '../../utils/msdf';
+import * as React from "react";
+export interface MsdfAtlasRegistryValue {
+    get(fontKey: string): MsdfAtlas | undefined;
+}
+export declare const MsdfAtlasProvider: React.FC<{
+    value: MsdfAtlasRegistryValue;
+    children: React.ReactNode;
+}>;
+export declare function useMsdfAtlas(fontKey: string | undefined): MsdfAtlas | undefined;
+export declare class MsdfAtlasRegistry implements MsdfAtlasRegistryValue {
+    private readonly map;
+    set(fontKey: string, atlas: MsdfAtlas): void;
+    get(fontKey: string): MsdfAtlas | undefined;
+    has(fontKey: string): boolean;
+}

package/dist/components/AepComposition/pathToThreeShape.d.ts

@@ -0,0 +1,4 @@
+import { AepShapePath } from '../../types/aep';
+import * as THREE from "three";
+export declare function pathToThreeShape(path: AepShapePath): THREE.Shape;
+export declare function pathHash(path: AepShapePath): string;

package/dist/components/AepComposition/resolveParentChain.d.ts

@@ -0,0 +1,3 @@
+import { AepLayer } from '../../types/aep';
+export declare function resolveParentChain(layer: AepLayer, byId: ReadonlyMap<string, AepLayer>): AepLayer[];
+export declare function buildParentChainIndex(layers: ReadonlyArray<AepLayer>): Map<string, AepLayer[]>;

package/dist/components/AepComposition/resolvePostFxList.d.ts

@@ -0,0 +1,2 @@
+import { AepCameraLayer, AepPostFx } from '../../types/aep';
+export declare function resolvePostFxList(authorPostFx: ReadonlyArray<AepPostFx> | undefined, camera: AepCameraLayer | undefined): AepPostFx[];

package/dist/components/AepComposition/shouldSplitText.d.ts

@@ -0,0 +1,26 @@
+import { AepLayer } from '../../types/aep';
+type AepTextLayer = Extract<AepLayer, {
+    kind: "text";
+}>;
+/**
+ * Router-level predicate: should a text layer render via `PixiTextSplit`
+ * (per-glyph, layout-engine-driven) vs the flat `PixiTextSprite` path?
+ *
+ * The split path runs the shared layout engine (aep-25 / aep-27) and
+ * samples every frame, so it owns per-frame animation. Forced when:
+ *
+ *  - `splitMode` is explicit (chars / words / lines).
+ *  - any `animators[]` are attached.
+ *  - multi-style `runs[]` cover the layer.
+ *  - `style.align` is any justify variant (slack distribution needs
+ *    per-glyph placement).
+ *  - `style.fill` is animated (keyframe array) — aep-29 parity:
+ *    `PixiTextSprite` takes a flat string color, so animated +/- themed
+ *    fills only animate via the split path.
+ *
+ * Static themed fills (the `{ themeKey, default }` object form) still
+ * route to the non-split sprite — they resolve once via the theme map
+ * and re-render on theme prop change without remount.
+ */
+export declare function shouldSplitText(layer: AepTextLayer): boolean;
+export {};

package/dist/components/AepComposition/threeTextureFromPixi.d.ts

@@ -0,0 +1,8 @@
+import * as PIXI from "pixi.js";
+import * as THREE from "three";
+export interface ThreeTextureBridge {
+    texture: THREE.Texture;
+    refresh: (app: PIXI.Application, rt: PIXI.RenderTexture) => void;
+    dispose: () => void;
+}
+export declare function threeTextureFromPixi(): ThreeTextureBridge;

package/dist/components/AepComposition/useAepLayerTransform.d.ts

@@ -0,0 +1,18 @@
+import { AepLayer } from '../../types/aep';
+export interface AepResolvedTransform {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    scale: [number, number];
+    rotation: number;
+    alpha: number;
+    anchor: {
+        x: number;
+        y: number;
+    };
+}
+export declare function useAepLayerTransform(layer: AepLayer, intrinsicSize: {
+    width: number;
+    height: number;
+}): AepResolvedTransform;

package/dist/components/AepComposition/useAepLayerTransform3D.d.ts

@@ -0,0 +1,8 @@
+import { AepLayer } from '../../types/aep';
+export interface AepResolvedTransform3D {
+    position: [number, number, number];
+    rotationEuler: [number, number, number];
+    scale: [number, number, number];
+    alpha: number;
+}
+export declare function useAepLayerTransform3D(layer: AepLayer): AepResolvedTransform3D;

package/dist/components/AepComposition/useMsdfAtlasRegistry.d.ts

@@ -0,0 +1,6 @@
+import { AepCompositionJson } from '../../types/aep';
+import { MsdfAtlasRegistry } from './msdfAtlasRegistry';
+export declare function useMsdfAtlasRegistry(comp: AepCompositionJson | null): {
+    registry: MsdfAtlasRegistry;
+    ready: number;
+};

package/dist/components/AepComposition/usePixiRenderTexture.d.ts

@@ -0,0 +1,14 @@
+import * as PIXI from "pixi.js";
+type TextureFactory = (width: number, height: number) => PIXI.RenderTexture;
+export declare function _setTextureFactory(fn: TextureFactory | null): void;
+declare function acquire(width: number, height: number): PIXI.RenderTexture;
+declare function release(tex: PIXI.RenderTexture): void;
+export declare const _acquire: typeof acquire;
+export declare const _release: typeof release;
+export declare function _poolStats(): {
+    totalEntries: number;
+    inUseCount: number;
+};
+export declare function _poolReset(): void;
+export declare function usePixiRenderTexture(width: number, height: number): PIXI.RenderTexture;
+export {};

package/dist/components/AepComposition/useResolveAsset.d.ts

@@ -0,0 +1,8 @@
+export type AepAssetState = "idle" | "loading" | "ready" | "error";
+export interface AepResolvedAssetState {
+    url: string;
+    mime?: string;
+    state: AepAssetState;
+    error?: unknown;
+}
+export declare function useResolveAsset(assetId: string | undefined): AepResolvedAssetState;

package/dist/components/AepMask/AepMaskContainer.d.ts

@@ -0,0 +1,9 @@
+import { AepMask } from '../../types/aep';
+import * as React from "react";
+export interface AepMaskContainerProps {
+    masks: ReadonlyArray<AepMask>;
+    children: React.ReactNode;
+    fps?: number;
+    inPointFrames?: number;
+}
+export declare const AepMaskContainer: React.FC<AepMaskContainerProps>;

package/dist/components/AepMask/PixiTrackMatte.d.ts

@@ -0,0 +1,10 @@
+import { AepTrackMatte } from '../../types/aep';
+import * as React from "react";
+export interface PixiTrackMatteProps {
+    source: React.ReactNode;
+    matted: React.ReactNode;
+    mode: AepTrackMatte["mode"];
+    width: number;
+    height: number;
+}
+export declare const PixiTrackMatte: React.FC<PixiTrackMatteProps>;

package/dist/components/AepMask/drawAepMask.d.ts

@@ -0,0 +1,3 @@
+import { AepMask } from '../../types/aep';
+import * as PIXI from "pixi.js";
+export declare function drawAepMaskComposite(g: PIXI.Graphics, masks: ReadonlyArray<AepMask>): void;

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

@@ -0,0 +1,5 @@
+export { AepMaskContainer } from './AepMaskContainer';
+export type { AepMaskContainerProps } from './AepMaskContainer';
+export { PixiTrackMatte } from './PixiTrackMatte';
+export type { PixiTrackMatteProps } from './PixiTrackMatte';
+export { drawAepMaskComposite } from './drawAepMask';

package/dist/components/PixiAudioSprite/HowlerAudioSprite.d.ts

@@ -1,12 +1,10 @@
-import { Howl } from 'howler';
-
-interface HowlerAudioPlayerProps {
+interface AudioPlayerProps {
     src: string;
     start: number;
     end: number;
 }
-interface IHowlerAudioPlayer {
-    sound: Howl | null;
+interface IAudioPlayer {
+    audio: HTMLAudioElement | null;
     isPlaying: boolean;
     currentTime: number;
     handlePause: () => void;
@@ -15,6 +13,6 @@ interface IHowlerAudioPlayer {
     handleSeek: (newTime: number) => void;
     playFromTime: (time: number) => void;
 }
-type UseHowlerAudioPlayer = (props: HowlerAudioPlayerProps) => IHowlerAudioPlayer;
-declare const useHowlerAudioPlayer: UseHowlerAudioPlayer;
+type UseAudioPlayer = (props: AudioPlayerProps) => IAudioPlayer;
+declare const useHowlerAudioPlayer: UseAudioPlayer;
 export default useHowlerAudioPlayer;

package/dist/components/PixiAudioSprite/PixiAudioSprite.d.ts

@@ -1,5 +1,6 @@
 import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
 import * as React from "react";
+import * as PIXI from "pixi.js";
 export interface PixiAudioSpriteProps extends PixiBaseSpriteProps {
     uniqueId: string;
     src: string;
@@ -10,6 +11,12 @@ export interface PixiAudioSpriteProps extends PixiBaseSpriteProps {
     mute: boolean;
     speed: number;
     visible: boolean;
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onAudioElementReady?: (uniqueId: string, el: HTMLAudioElement) => void;
 }
-declare const PixiAudioSprite: React.ForwardRefExoticComponent<PixiAudioSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
-export default PixiAudioSprite;
+declare const PixiAudioSprite: ({ ref, ...props }: PixiAudioSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const MemoizedPixiAudioSprite: typeof PixiAudioSprite;
+export default MemoizedPixiAudioSprite;

package/dist/components/PixiAudioSprite/useAudioVisualizer.d.ts

@@ -11,8 +11,8 @@ export type AudioVisualizerProps = Partial<PixiBaseSpriteProps> & {
     visible?: boolean;
 };
 declare const useAudioVisualizer: (audioProps: AudioVisualizerProps) => {
-    audioMotionRef: React.MutableRefObject<AudioMotionAnalyzer | undefined>;
+    audioMotionRef: React.RefObject<AudioMotionAnalyzer | undefined>;
     blobUrl: string;
-    canvasRef: React.MutableRefObject<HTMLDivElement | undefined>;
+    canvasRef: React.RefObject<HTMLDivElement | null>;
 };
 export default useAudioVisualizer;

package/dist/components/PixiAudioSprite/wave-config.d.ts

@@ -1,5 +1,4 @@
 import { Waveforms } from '../../types/Effects';
 import { Options, ConstructorOptions } from 'audiomotion-analyzer';
-
 export type WaveConfigOptions = Partial<ConstructorOptions & Options>;
 export declare const waveConfig: Record<Waveforms, WaveConfigOptions>;

package/dist/components/PixiGifSprite/PixiGifGsapSync.d.ts

@@ -1,19 +1,23 @@
 import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
 import * as React from "react";
+import * as PIXI from "pixi.js";
 export interface PixiGifSpriteProps extends PixiBaseSpriteProps {
     uniqueId: string;
     src: string;
     startAt: number;
     endAt: number;
-    frameStartAt: number;
-    frameEndAt: number;
-    locked: boolean;
-    loop: boolean;
+    frameStartAt?: number;
+    frameEndAt?: number;
+    loop?: boolean;
+    animationSpeed?: number;
+    locked?: boolean;
+    mute?: 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;
 }
-/**
- * PixiGifSprite Component is used to render gif image
- * @param props Gif Sprite props
- * @returns
- */
-declare const PixiGifSprite: React.ForwardRefExoticComponent<PixiGifSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
+declare const PixiGifSprite: React.MemoExoticComponent<({ ref, ...props }: PixiGifSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element>;
 export default PixiGifSprite;

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

@@ -1,4 +1,17 @@
 import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
 import * as React from "react";
-declare const PixiImageSprite: React.ForwardRefExoticComponent<PixiBaseSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
+import * as PIXI from "pixi.js";
+type PixiImageSpriteProps = PixiBaseSpriteProps & {
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    mouseOverTransformerRef?: {
+        current?: {
+            isDragging?: boolean;
+        } | null;
+    };
+};
+declare const PixiImageSpriteInner: ({ ref, ...props }: PixiImageSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiImageSprite: typeof PixiImageSpriteInner;
 export default PixiImageSprite;

package/dist/components/PixiLottieSprite/PixiLottieSprite.d.ts

@@ -1,5 +1,6 @@
 import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
 import * as React from "react";
+import * as PIXI from "pixi.js";
 export interface PixiLottieSpriteProps extends PixiBaseSpriteProps {
     uniqueId: string;
     src: string;
@@ -9,6 +10,11 @@ export interface PixiLottieSpriteProps extends PixiBaseSpriteProps {
     frameEndAt: number;
     locked: boolean;
     loop: boolean;
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
 }
-declare const PixiLottieSprite: React.ForwardRefExoticComponent<PixiLottieSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
-export default PixiLottieSprite;
+declare const PixiLottieSprite: ({ ref, ...props }: PixiLottieSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const MemoizedPixiLottieSprite: typeof PixiLottieSprite;
+export default MemoizedPixiLottieSprite;

package/dist/components/PixiNullObject/PixiNullObject.d.ts

@@ -0,0 +1,25 @@
+import { ForwardedRefResponse, PixiBaseSpriteProps } from '../../types/BaseProps';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiNullObjectProps extends Omit<PixiBaseSpriteProps, "transformation"> {
+    transformation: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        anchor: number | {
+            x: number;
+            y: number;
+        };
+        rotation?: number;
+        alpha?: number;
+        scale?: number | [number, number];
+    };
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+declare const PixiNullObjectInner: ({ ref, ...props }: PixiNullObjectProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiNullObject: typeof PixiNullObjectInner;
+export default PixiNullObject;

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

@@ -0,0 +1,2 @@
+export { default as PixiNullObject } from './PixiNullObject';
+export type { PixiNullObjectProps } from './PixiNullObject';

package/dist/components/PixiPreComp/PixiPreComp.d.ts

@@ -0,0 +1,29 @@
+import { ForwardedRefResponse, PixiBaseSpriteProps } from '../../types/BaseProps';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiPreCompProps extends Omit<PixiBaseSpriteProps, "transformation"> {
+    compId: string;
+    layerInPointFrames: number;
+    precompWidth: number;
+    precompHeight: number;
+    transformation: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        anchor: number | {
+            x: number;
+            y: number;
+        };
+        rotation?: number;
+        alpha?: number;
+        scale?: number | [number, number];
+    };
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+declare const PixiPreCompInner: ({ ref, ...props }: PixiPreCompProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element | null;
+declare const PixiPreComp: typeof PixiPreCompInner;
+export default PixiPreComp;

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

@@ -0,0 +1,3 @@
+export { default as PixiPreComp } from './PixiPreComp';
+export type { PixiPreCompProps } from './PixiPreComp';
+export { validatePrecompDepth } from './validatePrecompDepth';

package/dist/components/PixiPreComp/validatePrecompDepth.d.ts

@@ -0,0 +1,2 @@
+import { AepCompositionJson } from '../../types/aep';
+export declare function validatePrecompDepth(comp: AepCompositionJson, max?: number, depth?: number): void;

package/dist/components/PixiRemotionSprite/PixiRemotionGifSprite.d.ts

@@ -0,0 +1,24 @@
+import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiRemotionGifSpriteProps extends PixiBaseSpriteProps {
+    uniqueId: string;
+    src: string;
+    frameStartAt?: number;
+    frameEndAt?: number;
+    loop?: boolean;
+    /**
+     * Remotion-driven frame index. When provided, the underlying
+     * `GifSprite.currentFrame` is seeked to match — frame-accurate playback
+     * in Remotion's render loop. Omit for real-time playback (browser).
+     */
+    remotionFrame?: number;
+    /** Frames per second of the host composition. Defaults to 30. */
+    fps?: number;
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+declare const PixiRemotionGifSpriteInner: ({ ref, ...props }: PixiRemotionGifSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiRemotionGifSprite: typeof PixiRemotionGifSpriteInner;
+export default PixiRemotionGifSprite;

package/dist/components/PixiRemotionSprite/PixiRemotionImageSprite.d.ts

@@ -0,0 +1,18 @@
+import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface CanvasImageSource {
+    getCanvas: () => HTMLCanvasElement | HTMLImageElement | null;
+}
+export interface PixiRemotionImageSpriteProps extends PixiBaseSpriteProps {
+    uniqueId: string;
+    locked?: boolean;
+    canvasImageRef?: CanvasImageSource;
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+declare const PixiRemotionImageSpriteInner: ({ ref, ...props }: PixiRemotionImageSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiRemotionImageSprite: typeof PixiRemotionImageSpriteInner;
+export default PixiRemotionImageSprite;

package/dist/components/PixiRemotionSprite/PixiRemotionSprite.d.ts

@@ -22,5 +22,8 @@ export interface PixiRemotionSpriteProps extends PixiBaseSpriteProps {
     onAnchorTransformationEnd?: (endData: any) => void;
     canvasImageRef?: CanvasImageProps;
 }
-declare const PixiRemotionSprite: React.ForwardRefExoticComponent<PixiRemotionSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
-export default PixiRemotionSprite;
+declare const PixiRemotionSprite: ({ ref, ...props }: PixiRemotionSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const MemoizedPixiRemotionSprite: typeof PixiRemotionSprite;
+export default MemoizedPixiRemotionSprite;

package/dist/components/PixiRemotionSprite/PixiRemotionVideoCanvaSprite.d.ts

@@ -0,0 +1,20 @@
+import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import { CanvasImageSource } from './PixiRemotionImageSprite';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiRemotionVideoCanvaSpriteProps extends PixiBaseSpriteProps {
+    uniqueId: string;
+    src?: string;
+    frameStartAt?: number;
+    frameEndAt?: number;
+    mute?: boolean;
+    locked?: boolean;
+    fps?: number;
+    canvasImageRef?: CanvasImageSource;
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+declare const PixiRemotionVideoCanvaSpriteInner: ({ ref, ...props }: PixiRemotionVideoCanvaSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiRemotionVideoCanvaSprite: typeof PixiRemotionVideoCanvaSpriteInner;
+export default PixiRemotionVideoCanvaSprite;

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

@@ -1 +1,5 @@
 export { default as PixiRemotionSprite } from './PixiRemotionSprite';
+export { default as PixiRemotionImageSprite } from './PixiRemotionImageSprite';
+export { default as PixiRemotionVideoCanvaSprite } from './PixiRemotionVideoCanvaSprite';
+export { default as PixiRemotionGifSprite } from './PixiRemotionGifSprite';
+export type { CanvasImageSource } from './PixiRemotionImageSprite';

package/dist/components/PixiSVGSprite/PixiMorphSvgSprite.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 PixiMorphSvgSpriteProps extends PixiBaseSpriteProps {
+    uniqueId: string;
+    pathSequence: string[];
+    startAt: number;
+    endAt: number;
+    morphDuration?: number;
+    morphEase?: string;
+    loopBackToStart?: boolean;
+    viewBox?: string;
+    transformation: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        anchor: number | {
+            x: number;
+            y: number;
+        };
+        rotation?: number;
+        alpha?: number;
+        scale?: number;
+        tint?: number;
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+declare const PixiMorphSvgSprite: ({ ref, ...props }: PixiMorphSvgSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+export default PixiMorphSvgSprite;