reacthub-pixitweenjs 0.3.0 → 0.3.2-alpha.0

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

@@ -1,4 +1,4 @@
-import { AepCompositionJson, AepThemeMap } from '../../types/aep';
+import { AepCompositionJson, AepThemeMap, AepTransitionOverrideMap } from '../../types/aep';
 import { AepTextOverrideMap } from './AepTextOverrideContext';
 import { AepAssetOverrideMap } from './AepLayerProvider';
 import { AepAssetResolver } from './AepAssetResolver';
@@ -12,6 +12,7 @@ export interface AepCompositionProps {
     onError?: (err: unknown) => void;
     theme?: AepThemeMap;
     textOverrides?: AepTextOverrideMap;
+    transitionOverrides?: AepTransitionOverrideMap;
     onRenderReady?: () => void;
     onLayerError?: (layerId: string, error: unknown) => void;
 }

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

@@ -0,0 +1,16 @@
+import { AepTransitionOverrideMap } from '../../types/aep';
+import * as React from "react";
+import type * as PIXI from "pixi.js";
+export interface AepTransitionRegistryValue {
+    containers: Map<string, PIXI.Container>;
+    prefix: string;
+    overrides?: AepTransitionOverrideMap;
+    revision: number;
+    registerContainer: (layerId: string, container: PIXI.Container | null) => void;
+}
+export declare const AepTransitionProvider: React.FC<{
+    children: React.ReactNode;
+    overrides?: AepTransitionOverrideMap;
+    prefix?: string;
+}>;
+export declare const useAepTransitionRegistry: () => AepTransitionRegistryValue | null;

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

@@ -0,0 +1,7 @@
+import { AepTransition, AepTransitionOverrideMap } from '../../types/aep';
+import * as React from "react";
+export interface AepTransitionLayerProps {
+    transition: AepTransition;
+    overrides?: AepTransitionOverrideMap;
+}
+export declare const AepTransitionLayer: React.FC<AepTransitionLayerProps>;

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

@@ -0,0 +1,7 @@
+import { AepTransition, AepTransitionOverrideMap } from '../../types/aep';
+import * as React from "react";
+export interface AepTransitionMeshProps {
+    transition: AepTransition;
+    overrides?: AepTransitionOverrideMap;
+}
+export declare const AepTransitionMesh: React.FC<AepTransitionMeshProps>;

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

@@ -3,6 +3,14 @@ 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 { AepTransitionProvider, useAepTransitionRegistry } from './AepTransitionContext';
+export type { AepTransitionRegistryValue } from './AepTransitionContext';
+export { AepTransitionLayer } from './AepTransitionLayer';
+export type { AepTransitionLayerProps } from './AepTransitionLayer';
+export { AepTransitionMesh } from './AepTransitionMesh';
+export type { AepTransitionMeshProps } from './AepTransitionMesh';
+export { useAepTransitionClock } from './useAepTransitionClock';
+export { getAepTransitionEase } from './transitionEase';
 export { Aep3DScene } from './Aep3DScene';
 export type { Aep3DSceneProps } from './Aep3DScene';
 export { Aep3DPostFx } from './Aep3DPostFx';

package/dist/components/AepComposition/model3d/Pixi3DModelLayer.d.ts

@@ -6,4 +6,4 @@ export interface Pixi3DModelLayerProps extends PixiBaseSpriteProps {
 }
 export declare const Pixi3DModelLayer: React.MemoExoticComponent<({ ref, layer, ...props }: Pixi3DModelLayerProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element>;
+}) => React.JSX.Element>;

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

@@ -0,0 +1,2 @@
+import { AepEaseHandle } from '../../types/aep';
+export declare const getAepTransitionEase: (ease: AepEaseHandle | string | undefined) => ((progress: number) => number);

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

@@ -0,0 +1,2 @@
+import { TransitionClock } from '../../hooks/glTransitions/useGLTransitionMesh';
+export declare const useAepTransitionClock: (startFrame: number, durationFrames: number, ease?: TransitionClock["ease"]) => TransitionClock;

package/dist/components/PixiAnimatedSprite/PixiAnimatedSprite.d.ts

@@ -19,5 +19,5 @@ type PixiAnimatedSpriteProps = {
     onComplete?: () => void;
     onFrameChange?: (currentFrame: number) => void;
 };
-declare const PixiAnimatedSprite: React.MemoExoticComponent<({ isPlaying, forwardRef, ...props }: PixiAnimatedSpriteProps) => import("react/jsx-runtime").JSX.Element>;
+declare const PixiAnimatedSprite: React.MemoExoticComponent<({ isPlaying, forwardRef, ...props }: PixiAnimatedSpriteProps) => React.JSX.Element>;
 export default PixiAnimatedSprite;

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

@@ -53,6 +53,6 @@ export interface PixiAudioSpriteProps extends PixiBaseSpriteProps {
  */
 declare const PixiAudioSprite: ({ ref, ...props }: PixiAudioSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const MemoizedPixiAudioSprite: typeof PixiAudioSprite;
 export default MemoizedPixiAudioSprite;

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

@@ -78,7 +78,7 @@ export interface PixiCaptionsTrackProps {
  * `wordbox` branch no longer contains a stray unreachable statement.
  */
 declare const PixiCaptionsTrackInner: {
-    (props: PixiCaptionsTrackProps): import("react/jsx-runtime").JSX.Element;
+    (props: PixiCaptionsTrackProps): React.JSX.Element;
     displayName: string;
 };
 declare const PixiCaptionsTrack: typeof PixiCaptionsTrackInner;

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

@@ -19,5 +19,5 @@ export interface PixiGifSpriteProps extends PixiBaseSpriteProps {
 }
 declare const PixiGifSprite: React.MemoExoticComponent<({ ref, ...props }: PixiGifSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element>;
+}) => React.JSX.Element>;
 export default PixiGifSprite;

package/dist/components/PixiGlTransition/GlTransitionRegistry.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+export { useGlTransitionRegistry } from './GlTransitionRegistryContext';
+export type { GlTransitionRegistryValue } from './GlTransitionRegistryContext';
+export { resolveSequenceTransitions } from './sequenceTransitions';
+export type { RegisteredSequenceTransition, SequenceRegistryEntry, SequenceTransitionShortcut, } from './sequenceTransitions';
+export interface GlTransitionRegistryProviderProps {
+    children: ReactNode;
+}
+export declare const GlTransitionRegistryProvider: ({ children }: GlTransitionRegistryProviderProps) => import('react').JSX.Element;

package/dist/components/PixiGlTransition/GlTransitionRegistryContext.d.ts

@@ -0,0 +1,10 @@
+import { Container } from 'pixi.js';
+import { SequenceRegistryEntry } from './sequenceTransitions';
+export interface GlTransitionRegistryValue {
+    containers: Map<string, Container>;
+    sequences: Map<string, SequenceRegistryEntry>;
+    revision: number;
+    registerSequence: (sequence: SequenceRegistryEntry | null, id: string) => void;
+}
+export declare const GlTransitionRegistryContext: import('react').Context<GlTransitionRegistryValue | null>;
+export declare const useGlTransitionRegistry: () => GlTransitionRegistryValue | null;

package/dist/components/PixiGlTransition/PixiElementTransition.d.ts

@@ -0,0 +1,2 @@
+import { PixiElementTransitionProps } from './transitionTypes';
+export declare const PixiElementTransition: import('react').MemoExoticComponent<(props: PixiElementTransitionProps) => import('react').JSX.Element>;

package/dist/components/PixiGlTransition/PixiGlTransition.d.ts

@@ -0,0 +1,7 @@
+import { PixiElementTransitionProps, PixiSceneTransitionProps } from './transitionTypes';
+export type PixiGlTransitionProps = ({
+    scope: "element";
+} & PixiElementTransitionProps) | ({
+    scope: "scene";
+} & PixiSceneTransitionProps);
+export declare const PixiGlTransition: import('react').MemoExoticComponent<(props: PixiGlTransitionProps) => import('react').JSX.Element>;

package/dist/components/PixiGlTransition/PixiSceneTransition.d.ts

@@ -0,0 +1,2 @@
+import { PixiSceneTransitionProps } from './transitionTypes';
+export declare const PixiSceneTransition: import('react').MemoExoticComponent<(props: PixiSceneTransitionProps) => import('react').JSX.Element>;

package/dist/components/PixiGlTransition/TransitionMeshLayer.d.ts

@@ -0,0 +1,10 @@
+import { PixiTransitionProps } from './transitionTypes';
+interface TransitionMeshLayerProps extends PixiTransitionProps {
+    scope: "element" | "scene";
+    zIndex?: number;
+    fromGroup?: string[];
+    toGroup?: string[];
+    sharedLayers?: string[];
+}
+export declare const TransitionMeshLayer: import('react').MemoExoticComponent<({ name, startAt, duration, ease, params, from, to, region, width, height, scope, zIndex, fromGroup, toGroup, sharedLayers, }: TransitionMeshLayerProps) => import('react').JSX.Element>;
+export {};

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

@@ -0,0 +1,7 @@
+export { PixiGlTransition } from './PixiGlTransition';
+export type { PixiGlTransitionProps } from './PixiGlTransition';
+export { PixiElementTransition } from './PixiElementTransition';
+export { PixiSceneTransition } from './PixiSceneTransition';
+export { GlTransitionRegistryProvider, resolveSequenceTransitions, type GlTransitionRegistryProviderProps, } from './GlTransitionRegistry';
+export type { RegisteredSequenceTransition, SequenceRegistryEntry, SequenceTransitionShortcut, } from './sequenceTransitions';
+export type { PixiElementTransitionProps, PixiSceneTransitionProps, PixiTransitionProps, TransitionEndpoint, } from './transitionTypes';

package/dist/components/PixiGlTransition/sequenceTransitions.d.ts

@@ -0,0 +1,32 @@
+import { Container } from 'pixi.js';
+import { GlTransitionParams } from '../../types/glTransition';
+import { TransitionEndpoint } from './transitionTypes';
+export interface SequenceTransitionShortcut {
+    name: string;
+    duration: number;
+    ease?: string;
+    params?: GlTransitionParams;
+    from?: TransitionEndpoint;
+    to?: TransitionEndpoint;
+}
+export interface SequenceRegistryEntry {
+    id: string;
+    startAt: number;
+    endAt: number;
+    zIndex: number;
+    container: Container;
+    transitionIn?: SequenceTransitionShortcut;
+    transitionOut?: SequenceTransitionShortcut;
+}
+export interface RegisteredSequenceTransition {
+    id: string;
+    from: TransitionEndpoint;
+    to: TransitionEndpoint;
+    name: string;
+    startAt: number;
+    duration: number;
+    ease?: string;
+    params?: GlTransitionParams;
+    zIndex: number;
+}
+export declare const resolveSequenceTransitions: (sequences: Iterable<SequenceRegistryEntry>) => RegisteredSequenceTransition[];

package/dist/components/PixiGlTransition/transitionTypes.d.ts

@@ -0,0 +1,28 @@
+import { Container } from 'pixi.js';
+import { GlTransitionParams } from '../../types/glTransition';
+import { TransitionRegion } from '../../utils/glTransitions/capture';
+export type TransitionEndpoint = string | Container | {
+    current: Container | null;
+} | (() => Container | null);
+export interface PixiTransitionProps {
+    name: string;
+    startAt: number;
+    duration: number;
+    ease?: string;
+    params?: GlTransitionParams;
+    from: TransitionEndpoint;
+    to: TransitionEndpoint;
+    region?: TransitionRegion;
+    /** Canvas size used for the transition's scene capture. */
+    width?: number;
+    height?: number;
+}
+export interface PixiElementTransitionProps extends PixiTransitionProps {
+    zIndex?: number;
+}
+export interface PixiSceneTransitionProps extends PixiTransitionProps {
+    fromGroup?: string[];
+    toGroup?: string[];
+    sharedLayers?: string[];
+    zIndex?: number;
+}

package/dist/components/PixiGlTransition/useGsapTransitionClock.d.ts

@@ -0,0 +1,2 @@
+import { TransitionClock } from '../../hooks/glTransitions/useGLTransitionMesh';
+export declare const useGsapTransitionClock: (start: number, duration: number, easeName?: string) => TransitionClock;

package/dist/components/PixiGlTransition/useTransitionEndpoints.d.ts

@@ -0,0 +1,6 @@
+import { Container } from 'pixi.js';
+import { TransitionEndpoint } from './transitionTypes';
+export declare const useTransitionEndpoints: (from: TransitionEndpoint, to: TransitionEndpoint) => () => {
+    from: Container<import('pixi.js').ContainerChild> | null;
+    to: Container<import('pixi.js').ContainerChild> | null;
+};

package/dist/components/PixiGsapAnims/FadeIn.d.ts

@@ -7,5 +7,5 @@ interface FadeInProps {
     };
     effect?: "pluse" | "bouncein" | "spin";
 }
-declare function FadeIn(props: FadeInProps): import("react/jsx-runtime").JSX.Element;
+declare function FadeIn(props: FadeInProps): React.JSX.Element;
 export { FadeIn };

package/dist/components/PixiGsapAnims/PixiFlipContainer.d.ts

@@ -5,5 +5,5 @@ interface PixiFlipContainerProps {
     duration: number;
     uniqueId?: string;
 }
-declare function PixiFlipContainer(props: PixiFlipContainerProps): import("react/jsx-runtime").JSX.Element;
+declare function PixiFlipContainer(props: PixiFlipContainerProps): React.JSX.Element;
 export { PixiFlipContainer };

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

@@ -29,6 +29,6 @@ type PixiImageSpriteProps = PixiBaseSpriteProps & {
  */
 declare const PixiImageSpriteInner: ({ ref, ...props }: PixiImageSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const PixiImageSprite: typeof PixiImageSpriteInner;
 export default PixiImageSprite;

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

@@ -15,6 +15,6 @@ export interface PixiLottieSpriteProps extends PixiBaseSpriteProps {
 }
 declare const PixiLottieSprite: ({ ref, ...props }: PixiLottieSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const MemoizedPixiLottieSprite: typeof PixiLottieSprite;
 export default MemoizedPixiLottieSprite;

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

@@ -20,6 +20,6 @@ export interface PixiNullObjectProps extends Omit<PixiBaseSpriteProps, "transfor
 }
 declare const PixiNullObjectInner: ({ ref, ...props }: PixiNullObjectProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const PixiNullObject: typeof PixiNullObjectInner;
 export default PixiNullObject;

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

@@ -24,6 +24,6 @@ export interface PixiPreCompProps extends Omit<PixiBaseSpriteProps, "transformat
 }
 declare const PixiPreCompInner: ({ ref, ...props }: PixiPreCompProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element | null;
+}) => React.JSX.Element | null;
 declare const PixiPreComp: typeof PixiPreCompInner;
 export default PixiPreComp;

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

@@ -19,6 +19,6 @@ export interface PixiRemotionGifSpriteProps extends PixiBaseSpriteProps {
 }
 declare const PixiRemotionGifSpriteInner: ({ ref, ...props }: PixiRemotionGifSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const PixiRemotionGifSprite: typeof PixiRemotionGifSpriteInner;
 export default PixiRemotionGifSprite;

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

@@ -13,6 +13,6 @@ export interface PixiRemotionImageSpriteProps extends PixiBaseSpriteProps {
 }
 declare const PixiRemotionImageSpriteInner: ({ ref, ...props }: PixiRemotionImageSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const PixiRemotionImageSprite: typeof PixiRemotionImageSpriteInner;
 export default PixiRemotionImageSprite;

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

@@ -24,6 +24,6 @@ export interface PixiRemotionSpriteProps extends PixiBaseSpriteProps {
 }
 declare const PixiRemotionSprite: ({ ref, ...props }: PixiRemotionSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const MemoizedPixiRemotionSprite: typeof PixiRemotionSprite;
 export default MemoizedPixiRemotionSprite;

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

@@ -15,6 +15,6 @@ export interface PixiRemotionVideoCanvaSpriteProps extends PixiBaseSpriteProps {
 }
 declare const PixiRemotionVideoCanvaSpriteInner: ({ ref, ...props }: PixiRemotionVideoCanvaSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const PixiRemotionVideoCanvaSprite: typeof PixiRemotionVideoCanvaSpriteInner;
 export default PixiRemotionVideoCanvaSprite;

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

@@ -31,5 +31,5 @@ export interface PixiMorphSvgSpriteProps extends PixiBaseSpriteProps {
 }
 declare const PixiMorphSvgSprite: ({ ref, ...props }: PixiMorphSvgSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 export default PixiMorphSvgSprite;

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

@@ -30,6 +30,6 @@ export interface PixiSvgImageSpriteProps extends PixiBaseSpriteProps {
  */
 declare const PixiSvgImageSpriteInner: ({ ref, ...props }: PixiSvgImageSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const PixiSvgImageSprite: typeof PixiSvgImageSpriteInner;
 export default PixiSvgImageSprite;

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

@@ -79,6 +79,6 @@ export interface PixiSvgPathSpriteProps extends PixiBaseSpriteProps {
  */
 declare const PixiSvgPathSprite: ({ ref, ...props }: PixiSvgPathSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const MemoizedPixiSvgPathSprite: typeof PixiSvgPathSprite;
 export default MemoizedPixiSvgPathSprite;

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

@@ -25,6 +25,6 @@ export interface PixiSvgRawSpriteProps extends PixiBaseSpriteProps {
  */
 declare const PixiSvgRawSpriteInner: ({ ref, ...props }: PixiSvgRawSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const PixiSvgRawSprite: typeof PixiSvgRawSpriteInner;
 export default PixiSvgRawSprite;

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

@@ -1,4 +1,6 @@
 import { default as React } from 'react';
+import { Container } from 'pixi.js';
+import { SequenceTransitionShortcut } from '../PixiGlTransition/sequenceTransitions';
 export interface PixiSequenceProps {
     children?: React.ReactNode;
     /** start time of the sequence in seconds */
@@ -19,6 +21,12 @@ export interface PixiSequenceProps {
      * The visibility window opens this many seconds before `startAt`.
      */
     entranceOverlapSec?: number;
+    /** Optional transition into this sequence; requires a surrounding GlTransitionRegistryProvider. */
+    transitionIn?: SequenceTransitionShortcut;
+    /** Optional transition out of this sequence; requires a surrounding GlTransitionRegistryProvider. */
+    transitionOut?: SequenceTransitionShortcut;
+    /** Internal host callback used by AEP transition capture. */
+    onSequenceContainerReady?: (container: Container | null) => void;
 }
 /**
  * PixiSequence - Unified timeline with alpha-based visibility control
@@ -32,4 +40,4 @@ export interface PixiSequenceProps {
  * - 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;
+export declare const PixiSequence: ({ children, startAt, endAt, uniqueId, hideOnExit, hideOnEntry, hideStart, hideEnd, zIndex, entranceOverlapSec, transitionIn, transitionOut, onSequenceContainerReady, }: PixiSequenceProps) => React.JSX.Element;

package/dist/components/PixiShapeLayer/PixiShapeLayer.d.ts

@@ -38,6 +38,6 @@ export interface PixiShapeLayerProps extends Omit<PixiBaseSpriteProps, "transfor
 }
 declare const PixiShapeLayerInner: ({ ref, ...props }: PixiShapeLayerProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const PixiShapeLayer: typeof PixiShapeLayerInner;
 export default PixiShapeLayer;

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

@@ -121,6 +121,6 @@ export interface PixiTextSpriteProps extends Omit<PixiBaseSpriteProps, "transfor
 }
 declare const PixiTextSprite: ({ ref, ...props }: PixiTextSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const MemoizedPixiTextSprite: typeof PixiTextSprite;
 export default MemoizedPixiTextSprite;

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

@@ -19,5 +19,5 @@ export interface PixiThreeModelSpriteProps extends PixiBaseSpriteProps {
 }
 export declare const PixiThreeModelSprite: React.MemoExoticComponent<({ ref, ...props }: PixiThreeModelSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element>;
+}) => React.JSX.Element>;
 export default PixiThreeModelSprite;

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

@@ -24,5 +24,5 @@ export interface PixiVideoSpriteProps extends PixiBaseSpriteProps {
 }
 declare const PixiVideoCanvasSyncSprite: ({ ref, ...props }: PixiVideoSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 export default PixiVideoCanvasSyncSprite;

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

@@ -49,6 +49,6 @@ export interface PixiVideoSpriteProps extends PixiBaseSpriteProps {
  */
 declare const PixiVideoSprite: ({ ref, ...props }: PixiVideoSpriteProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 declare const MemoizedPixiVideoSprite: typeof PixiVideoSprite;
 export default MemoizedPixiVideoSprite;

package/dist/components/index.d.ts

@@ -8,6 +8,7 @@ export * from './PixiCaptionsTrack';
 export * from './PixiVideoSprite';
 export * from './PixiAnimatedSprite';
 export * from './PixiSequence';
+export * from './PixiGlTransition';
 export * from './PixiRemotionSprite';
 export * from './PixiLottieSprite';
 export * from './PixiUnifiedTransformer';

package/dist/hocs/AbstractContainer.d.ts

@@ -33,5 +33,5 @@ interface AbstractContainerProps extends PixiBaseSpriteProps {
 }
 declare const AbstractContainer: ({ ref, ...props }: AbstractContainerProps & {
     ref?: React.Ref<ForwardedRefResponse | null>;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 export default AbstractContainer;

package/dist/hocs/BorderMaskContainer.d.ts

@@ -36,7 +36,7 @@ export interface BorderMaskContainerProps {
  *    its (0,0) origin to the parent's getBounds() and inflates transformer boxes
  */
 declare const BorderMaskContainer: {
-    ({ x, y, width, height, border, roundedCorners, maskShape, crop, spriteRef, children, }: BorderMaskContainerProps): import("react/jsx-runtime").JSX.Element;
+    ({ x, y, width, height, border, roundedCorners, maskShape, crop, spriteRef, children, }: BorderMaskContainerProps): React.JSX.Element;
     displayName: string;
 };
 export default BorderMaskContainer;

package/dist/hocs/OverlayTilingSprite.d.ts

@@ -1,3 +1,4 @@
+import * as React from "react";
 export declare enum OverlayTilingSpriteTypes {
     NONE = "none",
     NORMAL = "normal",
@@ -26,5 +27,5 @@ interface PixiOverlayProps {
     x: number;
     y: number;
 }
-export declare const PixiOverlayTilingSprite: (props: PixiOverlayProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const PixiOverlayTilingSprite: (props: PixiOverlayProps) => React.JSX.Element | null;
 export {};

package/dist/hooks/glTransitions/useGLTransitionMesh.d.ts

@@ -0,0 +1,34 @@
+import { Container } from 'pixi.js';
+import { TransitionPairBase } from '../../types/glTransition';
+import { MutableContainerRef, TransitionLayer, TransitionRegion } from '../../utils/glTransitions/capture';
+export interface TransitionClock {
+    /** Subscribe to the clock's current time; return an unsubscribe function. */
+    subscribe: (listener: (time: number) => void) => () => void;
+    start: number;
+    end: number;
+    duration: number;
+    ease?: (progress: number) => number;
+}
+export interface ResolvedTransitionEndpoints {
+    from: Container | null;
+    to: Container | null;
+}
+export interface TransitionLayerSet {
+    fromLayers: TransitionLayer[];
+    toLayers: TransitionLayer[];
+}
+export interface UseGLTransitionMeshOptions {
+    transitionPair: TransitionPairBase | null;
+    width: number;
+    height: number;
+    clock: TransitionClock | null;
+    resolveEndpoints: () => ResolvedTransitionEndpoints;
+    getLayerSets: (time: number, endpoints: ResolvedTransitionEndpoints) => TransitionLayerSet;
+    hideEndpointsInWindow?: boolean;
+    getRegion?: (endpoints: ResolvedTransitionEndpoints) => TransitionRegion | null;
+    /** Scene transitions capture the complete stage instead of endpoint bounds. */
+    fullCanvas?: boolean;
+    /** Cap on capture pixels; larger regions render at reduced resolution (default 1920x1080). */
+    maxRegionPixels?: number;
+}
+export declare const useGLTransitionMesh: ({ transitionPair, width, height, clock, resolveEndpoints, getLayerSets, hideEndpointsInWindow, getRegion, fullCanvas, maxRegionPixels, }: UseGLTransitionMeshOptions) => MutableContainerRef;

package/dist/hooks/index.d.ts

@@ -1,4 +1,6 @@
 export * from './useGsapEffect';
+export { useGLTransitionMesh } from './glTransitions/useGLTransitionMesh';
+export type { ResolvedTransitionEndpoints, TransitionClock, TransitionLayerSet, UseGLTransitionMeshOptions, } from './glTransitions/useGLTransitionMesh';
 export * from './useSpriteFilters';
 export * from './aep';
 export { default as usePixiAnimation } from './usePixiAnimation';

package/dist/importers/aep/index.d.ts

@@ -5,3 +5,4 @@ export { convertProperty, asNumber, asVec2, asScale, asOpacity, } from './bodymo
 export { lottieColorToHex } from './bodymovin-color';
 export { lintBodymovinJson, LottieLintError, type LintFinding, type LintReport, type LintSeverity, type LintOptions, } from './lottieLint';
 export { readPostFxExtension, readExtrusionExtension, } from './bodymovinExtensions';
+export { lintAepTransitions } from './transitionLint';

package/dist/importers/aep/transitionLint.d.ts

@@ -0,0 +1,3 @@
+import { AepCompositionJson } from '../../types/aep';
+import { LintReport } from './lottieLint';
+export declare const lintAepTransitions: (comp: AepCompositionJson) => LintReport;