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

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

@@ -1,4 +1,6 @@
 import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import { AudioFade, DuckWindow } from '../../utils/audio/gainEnvelope';
+import { AudioRegistry } from '../../utils/audio/audioRegistry';
 import * as React from "react";
 import * as PIXI from "pixi.js";
 export interface PixiAudioSpriteProps extends PixiBaseSpriteProps {
@@ -6,13 +8,51 @@ export interface PixiAudioSpriteProps extends PixiBaseSpriteProps {
     src: string;
     startAt: number;
     endAt: number;
+    /** Offset into the audio FILE the clip starts from (seconds). */
     audioStartAt: number;
-    audioEndAt: number;
+    /** @deprecated Unused. The clip length on the timeline is `endAt - startAt`. */
+    audioEndAt?: number;
     mute: boolean;
     speed: number;
     visible: boolean;
+    /** 0..1. Default 1. */
+    volume?: number;
+    /**
+     * Volume as a function of timeline time in seconds (wins over `volume`). Lets an animation
+     * drive the base volume while fades / ducking / mute still apply on top.
+     */
+    getVolume?: (timelineTime: number) => number;
+    audioFade?: AudioFade;
+    duckWindows?: DuckWindow[];
+    duckTo?: number;
+    /**
+     * Mount a private AudioPlaybackManager for this one clip (default true), so the sprite works
+     * standalone. Set false when the app mounts ONE manager for the whole timeline and passes all
+     * clips to it.
+     */
+    managePlayback?: boolean;
+    /** Registry to use instead of the shared default (isolates multiple players). */
+    registry?: AudioRegistry;
     onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    /** Fires once the clip's <audio> element exists (and again if it is replaced). */
+    onAudioElementReady?: (uniqueId: string, el: HTMLAudioElement) => void;
 }
-declare const PixiAudioSprite: React.ForwardRefExoticComponent<PixiAudioSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
-export default PixiAudioSprite;
+/**
+ * PixiAudioSprite — an audio clip on the timeline, with an optional spectrum visualization.
+ *
+ * Playback is owned by `AudioPlaybackManager` (Clippy's architecture: one listener on the master
+ * timeline decides what plays, where and how loud). This component:
+ *   1. feeds its clip to a manager (its own by default; `managePlayback={false}` to opt out),
+ *   2. exposes the clip's `<audio>` element to callers via `onAudioElementReady`,
+ *   3. draws the waveform from that same element when `transformation.waveform` is set.
+ *
+ * Replaces the previous per-sprite GSAP tween driving a private `Audio`, whose onStart/onUpdate
+ * hooks raced when sprites were added dynamically, had no drift correction, ignored volume and
+ * fades, and re-created the element whenever any prop changed.
+ */
+declare const PixiAudioSprite: ({ ref, ...props }: PixiAudioSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const MemoizedPixiAudioSprite: typeof PixiAudioSprite;
+export default MemoizedPixiAudioSprite;

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

@@ -1 +1,4 @@
 export { default as PixiAudioSprite } from './PixiAudioSprite';
+export type { PixiAudioSpriteProps } from './PixiAudioSprite';
+export { default as useAudioElementPlayer, useHowlerAudioPlayer, } from './HowlerAudioSprite';
+export { default as useAudioVisualizer } from './useAudioVisualizer';

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

@@ -1,18 +1,33 @@
 import { default as AudioMotionAnalyzer } from 'audiomotion-analyzer';
-import { PixiBaseSpriteProps } from '../../types/BaseProps';
-import * as React from "react";
-export type AudioVisualizerProps = Partial<PixiBaseSpriteProps> & {
+import { Waveforms } from '../../types/Effects';
+import { AudioRegistry } from '../../utils/audio/audioRegistry';
+export interface UseAudioVisualizerOptions {
     uniqueId: string;
-    src: string;
-    muted?: boolean;
-    volume?: number;
-    loop?: boolean;
-    playbackRate?: number;
-    visible?: boolean;
-};
-declare const useAudioVisualizer: (audioProps: AudioVisualizerProps) => {
-    audioMotionRef: React.MutableRefObject<AudioMotionAnalyzer | undefined>;
-    blobUrl: string;
-    canvasRef: React.MutableRefObject<HTMLDivElement | undefined>;
-};
+    waveform: Waveforms;
+    width: number;
+    height: number;
+    /** Defaults to the shared registry the AudioPlaybackManager writes to. */
+    registry?: AudioRegistry;
+}
+export interface AudioVisualizer {
+    /** The analyzer canvas, once an element exists to tap. Wrap it in a Pixi CanvasSource. */
+    canvas: HTMLCanvasElement | null;
+    analyzer: AudioMotionAnalyzer | null;
+}
+/**
+ * Audio spectrum visualization for a clip, driven by the SAME `<audio>` element the
+ * AudioPlaybackManager plays.
+ *
+ * What changed from the previous version (and why):
+ *  - it no longer `fetch`es the whole audio file into a blob just to build an element; it taps
+ *    the element the manager already owns, so there is one download and one playback path
+ *  - the element is routed through Web Audio ONCE, via the registry's shared source node, so a
+ *    visualizer and stereo pan can coexist (previously they were mutually exclusive: a second
+ *    `createMediaElementSource` throws)
+ *  - the analyzer shares the registry's audio context; the manager resumes it on play
+ *  - the analyzer is built once per (clip, size). A waveform change updates its options in place,
+ *    because rebinding a new source node to the element is rejected by the browser
+ *  - the analyzer and its host element are destroyed on unmount (they leaked before)
+ */
+export declare function useAudioVisualizer({ uniqueId, waveform, width, height, registry, }: UseAudioVisualizerOptions): AudioVisualizer;
 export default useAudioVisualizer;

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

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

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

@@ -0,0 +1,86 @@
+import { CaptionSegment } from '../../utils/captions';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+/** Style fields read from `transformation`. All optional; defaults suit a bottom caption. */
+export interface PixiCaptionsTransformation {
+    x?: number;
+    y?: number;
+    fontFamily?: string;
+    fontWeight?: string | number;
+    fontSize?: number;
+    fill?: string;
+    stroke?: string | number | null;
+    strokeWidth?: number;
+    dropShadow?: boolean;
+    dropShadowColor?: string | number;
+    dropShadowBlur?: number;
+    dropShadowAlpha?: number;
+    dropShadowAngle?: number;
+    dropShadowDistance?: number;
+    wordWrapWidth?: number;
+    align?: string;
+    padding?: number;
+    /** Active-word colour. */
+    highlightColor?: string;
+    /** Extra px between words, on top of the space. */
+    wordSpacing?: number;
+    /** Selects the render mode (see `captionModeFor`). */
+    captionStyleId?: string | null;
+    /** Background of the `boxed` modes: hex, rgb() or rgba(). */
+    captionBgColor?: string;
+    textTransform?: "none" | "uppercase" | "lowercase";
+    /** Pill behind the active word in `wordbox`. */
+    captionActiveWordBg?: string;
+}
+export interface PixiCaptionsTrackProps {
+    /** Cue list. Build one with `parseSubtitles`, `groupWordsIntoSegments` or `normalizeCaptionSegments`. */
+    segments: ReadonlyArray<CaptionSegment>;
+    uniqueId: string;
+    transformation?: PixiCaptionsTransformation;
+    /** Fallback render-mode id when `transformation.captionStyleId` is unset. */
+    style?: string | null;
+    visible?: boolean;
+    disabled?: boolean;
+    /** Caption item start/end on the timeline (s). Used to detect clip-local cue times. */
+    startAt?: number;
+    endAt?: number;
+    /**
+     * Pin the caption to this master-timeline time (seconds) instead of following the playhead.
+     * Makes the output a pure function of time: use it for frame-exact export.
+     */
+    currentTime?: number;
+    onContainerRefReady?: (uniqueId: string, ref: React.RefObject<PIXI.Container | null>) => void;
+    /** Click on the caption (the invisible hit area). */
+    onClick?: (uniqueId: string, event: unknown) => void;
+    mouseOverSpriteRef?: {
+        current?: unknown;
+    };
+}
+/**
+ * PixiCaptionsTrack — word-timed (karaoke) captions on the Pixi canvas.
+ *
+ * Ported from the Clippy editor. The frame is a PURE function of (style, words, t): the playhead
+ * picks the active word (`sampleCaptionAt`), the mode turns that into a look (`wordVisualFor`),
+ * and `layoutCaptionWords` places the words. No GSAP tweens per word, so scrub / seek / reverse
+ * need no tween state and the editor, a server render and an exported frame agree.
+ *
+ * Modes (by `captionStyleId`): pop, glow, boxed, vhs, wordbox, punch, slam, glowpop, springpop,
+ * and `none` (static line). See `captionModeFor`.
+ *
+ * All children use coordinates RELATIVE to the caption centre and the container is placed at
+ * (x, y). In Pixi v8 an empty Graphics contributes a (0,0) point to getLocalBounds(); with
+ * canvas-absolute children the bounds would span from the canvas origin and a transformer box
+ * would swallow the screen.
+ *
+ * Differences from the Clippy original: boxed backgrounds accept hex / rgb() / rgba() (it only
+ * read rgba()), the font/layout caches are flushed through the engine's font events, the blur
+ * filters are destroyed, an optional `currentTime` makes the output deterministic, and the
+ * `wordbox` branch no longer contains a stray unreachable statement.
+ */
+declare const PixiCaptionsTrackInner: {
+    (props: PixiCaptionsTrackProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PixiCaptionsTrack: typeof PixiCaptionsTrackInner;
+export default PixiCaptionsTrack;
+export { PixiCaptionsTrack };

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

@@ -0,0 +1,5 @@
+export { default as PixiCaptionsTrack } from './PixiCaptionsTrack';
+export type { PixiCaptionsTrackProps, PixiCaptionsTransformation, } from './PixiCaptionsTrack';
+export { useCaptionPlayhead } from './useCaptionPlayhead';
+export { useCaptionStyles } from './useCaptionStyles';
+export { useEmojiTextures } from './useEmojiTextures';

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

@@ -0,0 +1,31 @@
+import { CaptionRenderMode, CaptionSample, CaptionSegment } from '../../utils/captions';
+import type * as PIXI from "pixi.js";
+export interface UseCaptionPlayheadOptions {
+    containerRef: React.RefObject<PIXI.Container | null>;
+    segments: ReadonlyArray<CaptionSegment>;
+    mode: CaptionRenderMode;
+    disabled?: boolean;
+    /** Caption item timeline start / end (seconds), to detect clip-local cue times. */
+    itemStartSec?: number;
+    itemEndSec?: number;
+    /**
+     * Master-timeline time in seconds. When given, the caption is a PURE function of this value,
+     * computed during render: no playhead subscription and no frame lag. Use it for deterministic
+     * export (Remotion frame / fps). When omitted, the master GSAP playhead is followed.
+     */
+    currentTime?: number;
+}
+/**
+ * What the caption shows right now: the active segment, active word and how long that word has
+ * been on / has left.
+ *
+ * Followed mode listens to Pixi's per-frame `onRender` (one callback per frame actually drawn,
+ * no second rAF loop), reads the playhead seconds from the master timeline, and only calls
+ * setState when something visible changed. The word's elapsed/remaining ms change every frame,
+ * but only matter to modes that animate within a word, so other modes do not re-render per frame.
+ *
+ * Controlled mode (`currentTime`) never subscribes. Clippy's loop sets React state from inside
+ * Pixi's render callback, so the committed frame lags the playhead by one; that is fine for live
+ * preview and wrong for an offline renderer that seeks frame by frame.
+ */
+export declare function useCaptionPlayhead({ containerRef, segments, mode, disabled, itemStartSec, itemEndSec, currentTime, }: UseCaptionPlayheadOptions): CaptionSample;

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

@@ -0,0 +1,45 @@
+import { CaptionRenderMode, CaptionSegment } from '../../utils/captions';
+import * as PIXI from "pixi.js";
+export interface CaptionStyleInput {
+    fontFamily: string;
+    fontWeight: string | number;
+    fontSize: number;
+    fill: string;
+    align: string;
+    wordWrapWidth: number;
+    padding: number;
+    stroke: string | number | null;
+    strokeWidth: number;
+    dropShadow: boolean;
+    dropShadowColor: string | number;
+    dropShadowBlur: number;
+    dropShadowAlpha: number;
+    dropShadowAngle: number;
+    dropShadowDistance: number;
+    highlightColor: string;
+}
+/**
+ * Every TextStyle and filter the caption modes draw with.
+ *
+ * Fonts usually arrive after the first draw. Pixi caches font metrics per font string and keeps
+ * the fallback-font texture, so on `FONTS_LOADED` (via `useFontEpoch`) the metrics cache is
+ * flushed and the styles are rebuilt. Filters are destroyed when replaced and on unmount
+ * (Clippy leaked them).
+ *
+ * NOTE: `trim` is deliberately NOT set. In v8 trim shrinks the rendered texture, so an
+ * `anchor: 0.5` pivots on a trimmed size that varies per word (ascenders, descenders, shadow
+ * bleed) and words float at different baselines.
+ */
+export declare function useCaptionStyles(input: CaptionStyleInput, mode: CaptionRenderMode, segments: ReadonlyArray<CaptionSegment>): {
+    base: PIXI.TextStyle;
+    active: PIXI.TextStyle;
+    inactive: PIXI.TextStyle;
+    colour: Record<string, PIXI.TextStyle>;
+    vhs: {
+        cyan: PIXI.TextStyle;
+        magenta: PIXI.TextStyle;
+    } | null;
+    glowPopBlur: PIXI.BlurFilter;
+    springPopBlur: PIXI.BlurFilter;
+    bloomBlur: PIXI.BlurFilter;
+};

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

@@ -0,0 +1,8 @@
+import { CaptionSegment } from '../../utils/captions';
+import * as PIXI from "pixi.js";
+/**
+ * Textures for the emoji drawn above words in glow-pop. They come from the pinned Noto PNGs (or
+ * a word's own `emojiSrc`), not a system emoji font, so the editor and a server render draw the
+ * same glyph. Textures belong to Pixi's Assets cache and are not destroyed here.
+ */
+export declare function useEmojiTextures(segments: ReadonlyArray<CaptionSegment>, enabled: boolean): Record<string, PIXI.Texture>;

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

@@ -6,17 +6,18 @@ export interface PixiGifSpriteProps extends PixiBaseSpriteProps {
     src: string;
     startAt: number;
     endAt: number;
-    frameStartAt: number;
-    frameEndAt: number;
-    locked: boolean;
-    loop: boolean;
+    frameStartAt?: number;
+    frameEndAt?: number;
+    loop?: boolean;
+    animationSpeed?: number;
+    locked?: boolean;
+    mute?: boolean;
+    pointerdown?: () => void;
+    applyTransformer?: boolean;
     onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
 }
-/**
- * PixiGifSprite Component is used to render gif image
- * @param props Gif Sprite props
- * @returns
- */
-declare const PixiGifSprite: React.ForwardRefExoticComponent<PixiGifSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
+declare const PixiGifSprite: React.MemoExoticComponent<({ ref, ...props }: PixiGifSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element>;
 export default PixiGifSprite;

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

@@ -1,8 +1,34 @@
 import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
 import * as React from "react";
 import * as PIXI from "pixi.js";
-declare const PixiImageSprite: React.ForwardRefExoticComponent<PixiBaseSpriteProps & {
+type PixiImageSpriteProps = PixiBaseSpriteProps & {
     onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
-} & React.RefAttributes<ForwardedRefResponse | null>>;
+    mouseOverTransformerRef?: {
+        current?: {
+            isDragging?: boolean;
+        } | null;
+    };
+    /** Cleared when the sprite unmounts, so a host's hover state never points at a dead node. */
+    mouseOverSpriteRef?: {
+        current?: unknown;
+    };
+};
+/**
+ * PixiImageSprite — an image on the Pixi canvas.
+ *
+ * Uplifted from the Clippy editor:
+ *  - `src` is sanitised (a CDN origin wrongly prepended to a data: URI is stripped)
+ *  - extensionless URLs load (forced texture parser)
+ *  - the texture is cleared on `src` change / error / unmount instead of leaving a stale image
+ *  - the cancel race is gone (the load handle is created synchronously)
+ *  - width/height of 0 fall back to the texture's native size
+ *  - `crop`, `effects: {name, intensity, params}`, `neonColor` and `plateKey` are supported,
+ *    and `blendMode` goes through `useSpriteFilters` (a raw sprite blendMode is ignored in
+ *    Pixi v8 once the sprite has filters)
+ */
+declare const PixiImageSpriteInner: ({ ref, ...props }: PixiImageSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiImageSprite: typeof PixiImageSpriteInner;
 export default PixiImageSprite;

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

@@ -13,5 +13,8 @@ export interface PixiLottieSpriteProps extends PixiBaseSpriteProps {
     onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
 }
-declare const PixiLottieSprite: React.ForwardRefExoticComponent<PixiLottieSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
-export default PixiLottieSprite;
+declare const PixiLottieSprite: ({ ref, ...props }: PixiLottieSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const MemoizedPixiLottieSprite: typeof PixiLottieSprite;
+export default MemoizedPixiLottieSprite;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiMorphSvgSpriteProps extends PixiBaseSpriteProps {
+    uniqueId: string;
+    pathSequence: string[];
+    startAt: number;
+    endAt: number;
+    morphDuration?: number;
+    morphEase?: string;
+    loopBackToStart?: boolean;
+    viewBox?: string;
+    transformation: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        anchor: number | {
+            x: number;
+            y: number;
+        };
+        rotation?: number;
+        alpha?: number;
+        scale?: number;
+        tint?: number;
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+declare const PixiMorphSvgSprite: ({ ref, ...props }: PixiMorphSvgSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+export default PixiMorphSvgSprite;

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

@@ -0,0 +1,35 @@
+import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiSvgImageSpriteProps extends PixiBaseSpriteProps {
+    /** SVG URL, `data:image/svg+xml` URI, or any raster image URL. */
+    src: string;
+    transformation: PixiBaseSpriteProps["transformation"] & {
+        /** Tint colour (any CSS colour). Applied live, with no re-rasterisation. */
+        color?: string;
+        /** Alias for `color`. */
+        fill?: string;
+        stroke?: string;
+        /** Alias for `stroke` (used by templates). */
+        strokeColor?: string;
+        strokeWidth?: number;
+    };
+    mouseOverSpriteRef?: {
+        current?: unknown;
+    };
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+/**
+ * PixiSvgImageSprite — a TINTABLE svg: art drawn in white (e.g. an icon set) is rasterised
+ * once at `width x height x resolution` and recoloured with a sprite tint, so changing the
+ * colour never re-rasterises. Ported from the Clippy editor.
+ *
+ * The sprite stays mounted with `Texture.EMPTY` + alpha 0 until the raster is ready, so the
+ * transformer keeps a stable node and there is no remount flash on load or recolour.
+ * Resizing re-rasterises once, after the drag settles (see useSvgTexture).
+ */
+declare const PixiSvgImageSpriteInner: ({ ref, ...props }: PixiSvgImageSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiSvgImageSprite: typeof PixiSvgImageSpriteInner;
+export default PixiSvgImageSprite;