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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,43 @@
+import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import { AepAnimatable, AepShapePath, AepThemableColor } from '../../types/aep';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiShapeLayerProps extends Omit<PixiBaseSpriteProps, "transformation"> {
+    path: AepShapePath;
+    fill?: AepThemableColor;
+    stroke?: {
+        color: AepAnimatable<string>;
+        width: AepAnimatable<number>;
+        cap?: "butt" | "round" | "square";
+        join?: "miter" | "round" | "bevel";
+    };
+    trimPath?: {
+        start: AepAnimatable<number>;
+        end: AepAnimatable<number>;
+        offset?: AepAnimatable<number>;
+    };
+    transformation: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        anchor: number | {
+            x: number;
+            y: number;
+        };
+        rotation?: number;
+        alpha?: number;
+        scale?: number | [number, number];
+        tint?: number;
+        blendMode?: number;
+    };
+    fps?: number;
+    inPointFrames?: number;
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+declare const PixiShapeLayerInner: ({ ref, ...props }: PixiShapeLayerProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiShapeLayer: typeof PixiShapeLayerInner;
+export default PixiShapeLayer;

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

@@ -0,0 +1,20 @@
+import { AepShapePath } from '../../types/aep';
+import * as PIXI from "pixi.js";
+export interface AepStrokeSnapshot {
+    color: string;
+    width: number;
+    cap?: "butt" | "round" | "square";
+    join?: "miter" | "round" | "bevel";
+}
+export interface AepTrimSnapshot {
+    start: number;
+    end: number;
+    offset?: number;
+}
+export interface DrawShapeOpts {
+    path: AepShapePath;
+    fill?: string;
+    stroke?: AepStrokeSnapshot;
+    trim?: AepTrimSnapshot;
+}
+export declare function drawShape(g: PIXI.Graphics, opts: DrawShapeOpts): void;

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

@@ -0,0 +1,4 @@
+export { default as PixiShapeLayer } from './PixiShapeLayer';
+export type { PixiShapeLayerProps, } from './PixiShapeLayer';
+export { drawShape, type DrawShapeOpts, type AepStrokeSnapshot, type AepTrimSnapshot, } from './drawShape';
+export { samplePath, sampleBezierPath, trimPolyline, type Point, } from './samplePath';

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

@@ -0,0 +1,5 @@
+import { AepBezierPath, AepShapePath } from '../../types/aep';
+export type Point = [number, number];
+export declare function sampleBezierPath(path: AepBezierPath, samplesPerSegment?: number): Point[];
+export declare function samplePath(path: AepShapePath, samples?: number): Point[];
+export declare function trimPolyline(poly: Point[], start: number, end: number, offset?: number): Point[];

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

@@ -0,0 +1,26 @@
+import { AepLayer, AepTextAnimator } from '../../types/aep';
+import { AepTextLayoutGlyph } from '../../utils/textLayout';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+type AepTextLayer = Extract<AepLayer, {
+    kind: "text";
+}>;
+export interface PixiTextSplitProps {
+    layer: AepTextLayer;
+    animators?: ReadonlyArray<AepTextAnimator>;
+    x: number;
+    y: number;
+    maxGlyphs?: number;
+}
+export declare class TextStyleCache {
+    private readonly capacity;
+    private readonly map;
+    hits: number;
+    misses: number;
+    constructor(capacity?: number);
+    get(key: string, build: () => PIXI.TextStyle): PIXI.TextStyle;
+    get hitRate(): number;
+}
+export declare function _textSplitStyleKey(glyph: AepTextLayoutGlyph, color: string, styleSig?: string): string;
+export declare const PixiTextSplit: React.FC<PixiTextSplitProps>;
+export {};

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

@@ -3,7 +3,7 @@ import { Effects } from '../../types/Effects';
 import { Animations } from '../../types';
 import * as React from "react";
 import * as PIXI from "pixi.js";
-export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
+export interface PixiTextSpriteProps extends Omit<PixiBaseSpriteProps, "transformation"> {
     text: string;
     startAt: number;
     endAt: number;
@@ -13,7 +13,10 @@ export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
         y: number;
         width: number;
         height: number;
-        anchor: number;
+        anchor: number | {
+            x: number;
+            y: number;
+        };
         rotation?: number;
         alpha?: number;
         scale?: number | [number, number];
@@ -33,7 +36,6 @@ export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
         wordWrapWidth?: number;
         leading?: number;
         padding?: number;
-        border?: string;
         dropShadow?: boolean;
         dropShadowColor?: string | number;
         shadowOffsetX?: number;
@@ -42,13 +44,38 @@ export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
         blurEnabled?: boolean;
         blurRadius?: number;
         fill: string | number;
+        /** Two or more colours -> linear gradient fill (overrides `fill`). */
+        gradientColors?: (string | number)[];
+        gradientStops?: number[];
+        /** 0 = vertical (default), 1 = horizontal. */
+        gradientType?: 0 | 1;
         stroke?: string | number;
+        /** v8 name; `strokeThickness` (v7) is still accepted. */
+        strokeWidth?: number;
         strokeThickness?: number;
+        dropShadowAlpha?: number;
+        /** Radians. */
+        dropShadowAngle?: number;
+        dropShadowDistance?: number;
+        /**
+         * `"box"` (default) keeps the legacy behaviour: the background fills the sprite's
+         * `width x height`. `"hug"` sizes it to the measured text plus `backgroundPadding`.
+         */
+        backgroundFit?: "box" | "hug";
+        backgroundPadding?: number;
+        /** Background corner radius, px. */
+        backgroundRadius?: number;
         zIndex?: number;
         align?: string;
         textBaseline?: string;
         trim?: boolean;
         backgroundColor?: string;
+        /**
+         * Pixi v8.16+ tagged text. Keys are tag names (e.g. `bold`,
+         * `highlight`); values are partial TextStyle options applied to
+         * any substring wrapped in `<tag>…</tag>` in `text`.
+         */
+        tagStyles?: Record<string, Partial<PIXI.TextStyleOptions>>;
         colorCorrection?: {
             enabled?: boolean;
             temperature?: number;
@@ -70,6 +97,12 @@ export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
             scaleInput?: number;
         };
         effect?: Effects;
+        effects?: {
+            name?: Effects | string;
+            intensity?: number;
+            params?: Record<string, unknown>;
+        };
+        neonColor?: number | string | null;
     };
     pointerdown?: () => void;
     pointerup?: () => void;
@@ -83,7 +116,11 @@ export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
     onAnchorTransformationEnd?: (endData: any) => void;
     onDobuleClick?: () => void;
     onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onTextRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Text | null>) => void;
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
 }
-declare const PixiTextSprite: React.ForwardRefExoticComponent<PixiTextSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
-export default PixiTextSprite;
+declare const PixiTextSprite: ({ ref, ...props }: PixiTextSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const MemoizedPixiTextSprite: typeof PixiTextSprite;
+export default MemoizedPixiTextSprite;

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

@@ -1 +1,4 @@
 export { default as PixiTextSprite } from './PixiTextSprite';
+export { PixiTextSplit, type PixiTextSplitProps } from './PixiTextSplit';
+export { composeAnimators, selectorPerChar, rangeShapeValue, type AepCharOffset, } from './textAnimator';
+export { resolveTextSplitFills, type AepTextSplitFills, } from './resolveTextSplitFills';

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

@@ -0,0 +1,27 @@
+import { AepLayer, AepThemeMap } from '../../types/aep';
+type AepTextLayer = Extract<AepLayer, {
+    kind: "text";
+}>;
+/**
+ * Per-frame fill resolution for the split-text path. Hoists the work out
+ * of the per-glyph render loop and out of the React tree so it can be
+ * verified in isolation.
+ *
+ *   layerHex  — `style.fill` flattened against `theme` (theme refs
+ *               resolved, fallbacks honored) and then sampled at `frame`.
+ *               `undefined` when `style.fill` is missing.
+ *   runHexes  — same treatment for each entry in `style.runs[*].fill`
+ *               (plain hex animatable today; future work may admit
+ *               theme refs at this level too). Indexed by runIndex.
+ *               `undefined` entries mean "inherit from layer."
+ *
+ * The fallback color is intentionally `#ffffff` (engine default for
+ * text); callers may pass a different one if their renderer's default
+ * differs.
+ */
+export interface AepTextSplitFills {
+    layerHex: string | undefined;
+    runHexes: ReadonlyArray<string | undefined>;
+}
+export declare function resolveTextSplitFills(layer: AepTextLayer, theme: AepThemeMap | undefined, frame: number, fallback?: string): AepTextSplitFills;
+export {};

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

@@ -0,0 +1,22 @@
+import { AepAnimatable, AepRangeShape, AepTextAnimator, AepTextRangeSelector } from '../../types/aep';
+export declare function staticOf<T>(field: AepAnimatable<T> | undefined, fallback: T): T;
+export declare function rangeShapeValue(shape: AepRangeShape, t: number): number;
+export declare function selectorPerChar(range: AepTextRangeSelector, animatorAmount: number, count: number): number[];
+export interface AnimatorGlyphIndex {
+    charIndex: number;
+    wordIndex: number;
+    lineIndex: number;
+}
+export declare function selectorPerGlyph(range: AepTextRangeSelector, animatorAmount: number, glyphs: ReadonlyArray<AnimatorGlyphIndex>): number[];
+export interface AepCharOffset {
+    position: [number, number];
+    scale: [number, number];
+    rotation: number;
+    opacity: number;
+    fillMix: {
+        color: string;
+        amount: number;
+    } | null;
+}
+export declare function composeAnimators(animators: ReadonlyArray<AepTextAnimator>, glyphsOrCount: number | ReadonlyArray<AnimatorGlyphIndex>, amountOverrides?: ReadonlyArray<number>): AepCharOffset[];
+export declare const _identityCharOffset: AepCharOffset;

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

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

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

@@ -0,0 +1,14 @@
+import * as React from "react";
+export interface PixiThreeSpriteProps {
+    width?: number | string;
+    height?: number | string;
+    background?: string;
+    camera?: {
+        position?: [number, number, number];
+        fov?: number;
+    };
+    /** Add the default ambient + directional rig. Set false for custom lighting. */
+    defaultLights?: boolean;
+    children: React.ReactNode;
+}
+export declare const PixiThreeSprite: React.FC<PixiThreeSpriteProps>;

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

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

package/dist/components/PixiUnifiedTransformer/PixiUnifiedTransformer.d.ts

@@ -1,15 +1,16 @@
-import * as React from "react";
-import * as PIXI from "pixi.js";
+import * as React from 'react';
+import type * as PIXI from 'pixi.js';
 type RefsMap = Record<string, React.MutableRefObject<PIXI.Container | null>>;
+type MouseOverTransformerRef = React.MutableRefObject<{
+    isMouseOver?: boolean;
+    isDragging?: boolean;
+    dragType?: string | null;
+} | null>;
 type PixiUnifiedTransformerProps = {
     selectedElementIds: string[];
     containerRefsMap: RefsMap;
     spriteHelperRef?: React.MutableRefObject<any>;
-    mouseOverTransformerRef?: React.MutableRefObject<{
-        isMouseOver?: boolean;
-        isDragging?: boolean;
-        dragType?: string | null;
-    } | null>;
+    mouseOverTransformerRef?: MouseOverTransformerRef;
     isMultiSelect?: boolean;
     selectedGroupId?: string | null;
     selectedElementIdInGroup?: string | null;
@@ -20,7 +21,18 @@ type PixiUnifiedTransformerProps = {
     getRotationByElementId?: (uniqueId: string) => number | undefined;
     onDoubleClickElement?: (uniqueId: string) => void;
     onTransformChange?: (uniqueId: string) => void;
-    onTransformCommit?: (uniqueId: string, endData: any) => void;
+    onTransformCommit?: (uniqueId: string, endData: unknown) => void;
+    rotateEnabled?: boolean;
+    scaleEnabled?: boolean;
+    translateEnabled?: boolean;
+    skewEnabled?: boolean;
+    boxScalingEnabled?: boolean;
+    boxRotationEnabled?: boolean;
+    showNonFocusedBorders?: boolean;
+    focusedElementIndex?: number;
+    individualBorderColor?: number;
+    individualBorderThickness?: number;
+    individualBorderAlpha?: number;
 };
 declare const PixiUnifiedTransformer: React.FC<PixiUnifiedTransformerProps>;
 export default PixiUnifiedTransformer;

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

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

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

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

package/dist/components/index.d.ts

@@ -2,10 +2,17 @@ export * from './PixiImageSprite';
 export * from './PixiSVGSprite';
 export * from './PixiAudioSprite';
 export * from './PixiGifSprite';
+export * from './PixiThreeSprite';
 export * from './PixiTextSprite';
+export * from './PixiCaptionsTrack';
 export * from './PixiVideoSprite';
 export * from './PixiAnimatedSprite';
 export * from './PixiSequence';
 export * from './PixiRemotionSprite';
 export * from './PixiLottieSprite';
 export * from './PixiUnifiedTransformer';
+export * from './PixiShapeLayer';
+export * from './PixiNullObject';
+export * from './PixiPreComp';
+export * from './AepMask';
+export * from './AepComposition';