reacthub-pixitweenjs 0.3.0-alpha.5 → 0.3.1

package/LICENSE

@@ -1,13 +1,21 @@
-PixiTweenJS License
+MIT License
 
-Copyright (c) 2024 khanzzirfan (reacthub.ai@gmail.com)
+Copyright (c) 2024 khanzzirfan
 
-PixiTweenJS is source-available software. It is not open-source software
-according to the OSI Open Source Definition.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-You may use this software free of charge if you are an individual, a
-non-profit, or an organization with annual revenue or turnover of less than
-€1,000,000. Organizations with annual revenue or turnover of €1,000,000 or
-more must purchase a Company License for commercial use.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-See LICENSE.md for the complete terms.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSE.md

@@ -1,109 +1,21 @@
-# PixiTweenJS License
+# MIT License
 
-**Copyright (c) 2024 khanzzirfan (reacthub.ai@gmail.com)**
+Copyright (c) 2024 khanzzirfan
 
-PixiTweenJS is **source-available software**. It is not open-source software
-according to the Open Source Initiative's (OSI) Open Source Definition, and it
-is not released under the Apache License, the MIT License, or any other OSI
-approved license. The source code is publicly available, but the rights to use
-it are governed by this license.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
----
-
-## 1. Grant of License
-
-Subject to the terms of this license, the author grants you a
-non-exclusive, worldwide, royalty-free license to use, copy, modify, and
-create derivative works of the PixiTweenJS source code ("the Software") for
-the purpose of building and distributing your own products and services, in
-accordance with the conditions below.
-
-## 2. Free License
-
-You may use the Software without charge if you are:
-
-- **an individual** (including freelancers and contractors who are not part
-  of an organization that exceeds the threshold below);
-- **a non-profit organization**, a not-for-profit, or a public-benefit entity;
-- **an organization whose annual revenue or turnover is less than €1,000,000
-  (one million euros)** — measured on a consolidated basis across the
-  organization, including subsidiaries and parent companies;
-- **evaluating** the Software for a trial period before deciding whether to
-  purchase a Company License.
-
-Organizations whose annual revenue or turnover is **€1,000,000 or more** must
-purchase a **Company License** before using the Software in a commercial
-product or service.
-
-## 3. Company License
-
-A Company License grants the same usage and modification rights as the Free
-License to a single organization of any size, plus priority support, and
-permits commercial use without regard to the revenue threshold. Company
-Licenses are available from the author at the prices published on
-<https://pixitweenjs.xyz/license/pricing>.
-
-## 4. What You May Do
-
-- Use the Software in your own products and services, including commercial
-  ones (subject to Section 2 or a Company License).
-- Modify the Software and use your modified versions internally or in your
-  products.
-- Distribute the Software (or your modifications) as part of, or embedded
-  in, your products, provided your product is not itself a development
-  framework, SDK, or library that re-exports the Software's functionality as
-  a service or a competing product.
-
-## 5. What You May Not Do
-
-- Redistribute the Software, or substantial portions of it, **on its own** as
-  a library, SDK, or framework for other developers to build upon — whether
-  free, paid, or as part of another open-source project — unless your product
-  adds significant functionality beyond what the Software provides.
-- Sell, sublicense, or rent the Software, or portions of it, as a standalone
-  product or as a hosted "as-a-service" offering that exposes the Software's
-  rendering and composition capabilities to third parties as the primary
-  value of the service.
-- Remove or obscure any copyright, trademark, attribution, or license
-  notices present in the Software or its documentation.
-- Use the Software in any way that violates applicable law.
-
-## 6. Attribution
-
-Any product that uses the Software must include an attribution notice in a
-reasonable location (for example: the About dialog, the README, or the
-generated media metadata) that reads:
-
-> This product uses PixiTweenJS (https://pixitweenjs.xyz), used under the
-> PixiTweenJS License.
-
-If you modify the Software, the attribution must note that modifications were
-made.
-
-## 7. Warranty and Liability
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING
-FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-IN THE SOFTWARE.
-
-## 8. Termination
-
-This license is effective until terminated. It terminates automatically
-without notice if you fail to comply with any of its terms. Upon termination,
-you must cease all use and distribution of the Software and destroy all
-copies in your possession.
-
-## 9. Law and Jurisdiction
-
-This license is governed by the laws of the jurisdiction in which the author
-is domiciled, without regard to its conflict-of-law provisions.
-
----
-
-*If your organization's annual revenue or turnover is €1,000,000 or more, or
-you are unsure which license applies to you, contact
-reacthub.ai@gmail.com to purchase a Company License.*
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -486,7 +486,7 @@ function AnimatedHero({ args }) {
 - **[📖 Complete Documentation](https://pixitweenjs.xyz/docs/introduction)** - The docs site
 - **[🎮 Cookbook & Examples](https://pixitweenjs.xyz/docs/cookbook)** - Live, copy-paste recipes
 - **[💡 Installation Guide](https://pixitweenjs.xyz/docs/installation)**
-- **[🔒 License & Pricing](https://pixitweenjs.xyz/docs/license/overview)**
+- **[🔒 MIT License](https://pixitweenjs.xyz/docs/license/overview)**
 
 > Storybook is used as an **internal dev playground** for the library
 > itself (`yarn storybook`). It is no longer the public documentation
@@ -518,23 +518,9 @@ We welcome contributions! Please read our [Contributing Guide](Contribution.md)
 
 ## 📄 **License**
 
-PixiTweenJS is **source-available software** under the
-**[PixiTweenJS License](LICENSE.md)** (not an OSI-approved open-source
-license).
-
-It is **free** for:
-
-- individuals and freelancers,
-- non-profits / not-for-profits,
-- organizations with annual revenue or turnover **under €1M**.
-
-Organizations with annual revenue or turnover **€1M or more** must purchase a
-**Company License** for commercial use.
-
-See [License overview](https://pixitweenjs.xyz/docs/license/overview),
-[Pricing](https://pixitweenjs.xyz/docs/license/pricing), and the
-[FAQ](https://pixitweenjs.xyz/docs/license/faq). For licensing inquiries:
-**reacthub.ai@gmail.com**.
+PixiTweenJS is open-source software released under the
+**[MIT License](LICENSE)**. You may use, copy, modify, distribute, sublicense,
+and sell the software, subject to the license's notice-preservation condition.
 
 ---
 

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;