reacthub-pixitweenjs 0.2.109-alpha.7 → 0.3.0-alpha.4

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/AudioPlaybackManager.d.ts

@@ -0,0 +1,38 @@
+import { AudioRegistry } from '../../utils/audio/audioRegistry';
+import { AudioClipSpec } from '../../utils/audio/audioSync';
+import * as React from "react";
+export type AudioPlaybackElement = AudioClipSpec;
+export interface AudioPlaybackManagerProps {
+    audioElements: ReadonlyArray<AudioPlaybackElement>;
+    /** Defaults to the shared registry. Pass your own to isolate multiple players. */
+    registry?: AudioRegistry;
+    /**
+     * Stop and release EVERY element in the registry (and close its audio context) when this
+     * unmounts. Default true: right for the one editor-wide manager that owns the registry. Turn it
+     * off when the registry is shared with others and you only want to remove your own clips.
+     */
+    clearOnUnmount?: boolean;
+}
+/**
+ * AudioPlaybackManager — the single owner of audio playback. Renders nothing; mount it once,
+ * anywhere under the GSAP provider (it does not need to be inside the Pixi stage).
+ *
+ * Ported from the Clippy editor. The architecture is the point: ONE listener on the master
+ * timeline decides, for every clip, whether its element should be playing, where, and how loud.
+ * It replaces the old per-sprite GSAP tweens whose onStart/onUpdate hooks raced when clips were
+ * added dynamically, and it has no per-clip timing state to go stale.
+ *
+ * The decision itself is pure (`decideAudioSync`) and unit-tested; this component only owns the
+ * element lifecycle and the event wiring. Differences from Clippy:
+ *  - plain `HTMLAudioElement` instead of Howler (no dependency; same streaming behaviour as
+ *    Howler's html5 mode, which Clippy already uses)
+ *  - the playhead moving BACKWARDS or being scrubbed pauses the clips (Clippy kept playing
+ *    forward and re-seeked every 200 ms)
+ *  - the file position honours `speed` (Clippy's drifted at any speed other than 1)
+ *  - handles `play()` being blocked by the autoplay policy, and element load errors, instead of
+ *    silently stalling
+ *  - a RESUME event starts clips immediately rather than waiting for the next tick
+ */
+declare const AudioPlaybackManager: React.FC<AudioPlaybackManagerProps>;
+export default AudioPlaybackManager;
+export { AudioPlaybackManager };

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,42 @@
+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';
+export { AudioPlaybackManager } from './AudioPlaybackManager';
+export type { AudioPlaybackManagerProps, AudioPlaybackElement, } from './AudioPlaybackManager';
+export * from './model3d';

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/model3d/Pixi3DModelLayer.d.ts

@@ -0,0 +1,9 @@
+import { ForwardedRefResponse, PixiBaseSpriteProps } from '../../../types/BaseProps';
+import { AepModel3DLayer } from '../../../types/aep';
+import * as React from "react";
+export interface Pixi3DModelLayerProps extends PixiBaseSpriteProps {
+    layer: AepModel3DLayer;
+}
+export declare const Pixi3DModelLayer: React.MemoExoticComponent<({ ref, layer, ...props }: Pixi3DModelLayerProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element>;

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

@@ -0,0 +1,49 @@
+import * as THREE from "three";
+export interface OffscreenRenderRequest {
+    canvas: HTMLCanvasElement;
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    width: number;
+    height: number;
+}
+/** The slice of THREE.WebGLRenderer this service uses (lets tests inject a fake). */
+export interface OffscreenGlRenderer {
+    readonly domElement: HTMLCanvasElement;
+    setSize(width: number, height: number, updateStyle?: boolean): void;
+    setViewport(x: number, y: number, width: number, height: number): void;
+    render(scene: THREE.Scene, camera: THREE.Camera): void;
+    dispose(): void;
+    forceContextLoss(): void;
+}
+export declare class ThreeOffscreenRenderer {
+    readonly renderer: THREE.WebGLRenderer;
+    private readonly gl;
+    private width;
+    private height;
+    constructor(gl?: OffscreenGlRenderer);
+    render({ canvas, scene, camera, width, height }: OffscreenRenderRequest): void;
+    dispose(): void;
+}
+/**
+ * Reference-counted pool of shared things keyed by owner (a Pixi `Application`).
+ *
+ * The last release schedules disposal after a grace period, so a StrictMode double-mount or a
+ * stage remount reuses the same renderer instead of tearing down and recreating a WebGL context.
+ * Without this, every Application (each Storybook story switch, for example) leaked a context
+ * until the browser's ~16 context cap started dropping live ones.
+ */
+export declare function createRendererPool<T extends {
+    dispose(): void;
+}>(create: () => T, graceMs?: number): {
+    acquire(owner: unknown): T;
+    release(owner: unknown): void;
+    size: () => number;
+};
+/**
+ * Take a use of the shared renderer for a Pixi `Application` (or a process-wide fallback when no
+ * application is available, e.g. in tests/portals). Pair every call with `releaseOffscreenRenderer`.
+ */
+export declare function acquireOffscreenRenderer(app?: object | null): ThreeOffscreenRenderer;
+export declare function releaseOffscreenRenderer(app?: object | null): void;
+/** @deprecated Does not track ownership; use `acquireOffscreenRenderer` / `releaseOffscreenRenderer`. */
+export declare function getOffscreenRenderer(app?: object | null): ThreeOffscreenRenderer;

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

@@ -0,0 +1,30 @@
+export interface CameraFraming {
+    position: [number, number, number];
+    target: [number, number, number];
+}
+/**
+ * Fixed camera for a model whose rest-pose bounds are `center` / `maxDim`.
+ *
+ * The camera frames the UNSCALED, UNTRANSLATED model and never follows it. Following `view.position`
+ * or compensating for `view.scale` would cancel the very motion those keyframes describe (the
+ * object would sit still in the viewport). Use `camera.fit` to leave room for growth or travel.
+ */
+export declare function frameCamera(center: readonly [number, number, number], maxDim: number, fovDeg: number, fit: number): CameraFraming;
+/** Seconds into a glTF clip: relative to the layer's in-point, never negative. */
+export declare function clipTimeSeconds(frame: number, inPointFrames: number, fps: number): number;
+/** Whether `frame` is inside the layer's half-open window [inPoint, outPoint). */
+export declare function isFrameInRange(frame: number, inPointFrames: number, outPointFrames: number): boolean;
+export interface FramingBounds {
+    center: [number, number, number];
+    /** Largest edge, in model units. */
+    maxDim: number;
+}
+/**
+ * Bounds used to frame the camera. An authored `bounds` override wins over what was measured from
+ * the loaded model; its `center` defaults to the measured centre. Measured bounds of a skinned
+ * glTF are cached at the first pose and do not follow the animation, hence the override.
+ */
+export declare function resolveFramingBounds(measured: FramingBounds, override?: {
+    center?: readonly [number, number, number];
+    size: readonly [number, number, number];
+}): FramingBounds;

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

@@ -0,0 +1,27 @@
+import { AepModel3DSource } from '../../../types/aep';
+import * as THREE from "three";
+export type PrimitiveShape = Extract<AepModel3DSource, {
+    type: "primitive";
+}>["shape"];
+export interface PrimitiveProportions {
+    width?: number;
+    height?: number;
+    depth?: number;
+}
+export declare function buildPrimitiveGeometry(shape: PrimitiveShape, proportions?: PrimitiveProportions): THREE.BufferGeometry;
+export interface ExtrudeGeometryResult {
+    geometry: THREE.ExtrudeGeometry;
+    /** Contour width/height in the same units as the input points. */
+    width: number;
+    height: number;
+}
+export declare function buildExtrudeGeometry(contour: ReadonlyArray<readonly [number, number]>, depth: number, bevel?: number): ExtrudeGeometryResult;
+export interface BuiltSourceGeometry {
+    geometry: THREE.BufferGeometry;
+    /**
+     * True when the geometry has two material groups: caps (0) and sides (1).
+     * Boxes have six groups (+X, -X, +Y, -Y, +Z, -Z).
+     */
+    materialGroups: "single" | "extrude" | "box";
+}
+export declare function buildSourceGeometry(source: AepModel3DSource, sampledDepth: number): BuiltSourceGeometry;

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

@@ -0,0 +1,14 @@
+export { Pixi3DModelLayer } from './Pixi3DModelLayer';
+export type { Pixi3DModelLayerProps } from './Pixi3DModelLayer';
+export { AepReadinessProvider, useAepCompositionReady, useAepReadiness, } from './readiness';
+export type { AepReadinessContextValue } from './readiness';
+export { ThreeOffscreenRenderer, acquireOffscreenRenderer, releaseOffscreenRenderer, createRendererPool, getOffscreenRenderer, } from './ThreeOffscreenRenderer';
+export type { OffscreenRenderRequest, OffscreenGlRenderer, } from './ThreeOffscreenRenderer';
+export { frameCamera, clipTimeSeconds, isFrameInRange } from './framing';
+export type { CameraFraming } from './framing';
+export { LIGHTING_PRESETS, DEFAULT_LIGHTING_PRESET, resolveLightingConfig, directionFromAzimuthElevation, } from './lighting';
+export type { LightingConfig, LightingOverrides, LightingPresetName, LightingRig, } from './lighting';
+export { buildPrimitiveGeometry, buildExtrudeGeometry, buildSourceGeometry, } from './geometry';
+export type { PrimitiveShape, PrimitiveProportions, ExtrudeGeometryResult, BuiltSourceGeometry, } from './geometry';
+export { sampleModel3DState, model3DStateKey, MODEL3D_DEFAULTS, } from './sampleModel3D';
+export type { SampledModel3DState } from './sampleModel3D';

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

@@ -0,0 +1,40 @@
+import { AepModel3DLighting } from '../../../types/aep';
+import * as THREE from "three";
+export type LightingPresetName = NonNullable<AepModel3DLighting["preset"]>;
+export interface LightingConfig {
+    preset: LightingPresetName;
+    keyAzimuth: number;
+    keyElevation: number;
+    keyIntensity: number;
+    keyColor: string;
+    fillIntensity: number;
+    rimIntensity: number;
+    ambientIntensity: number;
+    environmentIntensity: number;
+    environment: "room" | "none";
+}
+export declare const LIGHTING_PRESETS: Record<LightingPresetName, LightingConfig>;
+export declare const DEFAULT_LIGHTING_PRESET: LightingPresetName;
+export interface LightingOverrides {
+    keyAzimuth?: number;
+    keyElevation?: number;
+    keyIntensity?: number;
+    keyColor?: string;
+    fillIntensity?: number;
+    rimIntensity?: number;
+}
+export declare function resolveLightingConfig(presetName?: LightingPresetName, overrides?: LightingOverrides, environment?: AepModel3DLighting["environment"]): LightingConfig;
+/** Unit vector pointing from the light's target toward the light. */
+export declare function directionFromAzimuthElevation(azimuthDeg: number, elevationDeg: number): [number, number, number];
+export interface LightingRig {
+    group: THREE.Group;
+    ambient: THREE.AmbientLight;
+    key: THREE.DirectionalLight;
+    fill: THREE.DirectionalLight;
+    rim: THREE.DirectionalLight;
+}
+export declare function createLightingRig(config: LightingConfig): LightingRig;
+export declare function applyLightingRig(rig: LightingRig, config: LightingConfig): void;
+export declare function disposeLightingRig(rig: LightingRig): void;
+export declare function getRoomEnvironmentTexture(renderer: THREE.WebGLRenderer): THREE.Texture;
+export declare function applyEnvironment(scene: THREE.Scene, config: LightingConfig, renderer: THREE.WebGLRenderer): void;

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

@@ -0,0 +1,17 @@
+import * as React from "react";
+export interface AepReadinessContextValue {
+    ready: boolean;
+    readyCount: number;
+    total: number;
+    register: (id: string) => () => void;
+    markReady: (id: string) => void;
+    reset: (id: string) => void;
+    reportError: (id: string, error: unknown) => void;
+}
+export declare function useAepCompositionReady(): boolean;
+export declare function useAepReadiness(): AepReadinessContextValue;
+export interface AepReadinessProviderProps {
+    children: React.ReactNode;
+    onLayerError?: (layerId: string, error: unknown) => void;
+}
+export declare const AepReadinessProvider: React.FC<AepReadinessProviderProps>;

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

@@ -0,0 +1,40 @@
+import { AepModel3DLayer } from '../../../types/aep';
+import { LightingPresetName } from './lighting';
+export interface SampledModel3DState {
+    rotation: [number, number, number];
+    position: [number, number, number];
+    scale: number;
+    extrudeDepth: number;
+    roughness: number;
+    metalness: number;
+    clearcoat: number;
+    preset: LightingPresetName;
+    keyAzimuth: number;
+    keyElevation: number;
+    keyIntensity: number;
+    keyColor: string;
+    fillIntensity: number;
+    rimIntensity: number;
+    environment: "room" | "none";
+    shadowOpacity: number;
+    shadowSoftness: number;
+    shadowOffsetY: number;
+    fov: number;
+    fit: number;
+}
+export declare const MODEL3D_DEFAULTS: {
+    readonly rotation: [number, number, number];
+    readonly position: [number, number, number];
+    readonly scale: 1;
+    readonly roughness: 0.35;
+    readonly metalness: 0.05;
+    readonly clearcoat: 0;
+    readonly shadowOpacity: 0.35;
+    readonly shadowSoftness: 0.6;
+    readonly shadowOffsetY: 0;
+    readonly fov: 35;
+    readonly fit: 1.35;
+};
+export declare function sampleModel3DState(layer: AepModel3DLayer, frame: number): SampledModel3DState;
+/** Deterministic identity for the sampled state, used for dirty checks. */
+export declare function model3DStateKey(state: SampledModel3DState): 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,12 @@ interface IHowlerAudioPlayer {
     handleSeek: (newTime: number) => void;
     playFromTime: (time: number) => void;
 }
-type UseHowlerAudioPlayer = (props: HowlerAudioPlayerProps) => IHowlerAudioPlayer;
-declare const useHowlerAudioPlayer: UseHowlerAudioPlayer;
-export default useHowlerAudioPlayer;
+type UseAudioPlayer = (props: AudioPlayerProps) => IAudioPlayer;
+declare const useAudioElementPlayer: UseAudioPlayer;
+/**
+ * Plain-`HTMLAudioElement` player hook (no Howler involved; the old name was a leftover).
+ * `useHowlerAudioPlayer` stays exported as an alias so existing imports keep working.
+ */
+export { useAudioElementPlayer };
+export declare const useHowlerAudioPlayer: UseAudioPlayer;
+export default useAudioElementPlayer;