@lottiefiles/dotlottie-web 0.40.1 → 0.41.0-pre.0

package/dist/dotlottie-BfDGpudA.d.cts

@@ -0,0 +1,463 @@
+declare namespace RuntimeExports {
+    let HEAPF32: unknown;
+    let HEAPF64: unknown;
+    let HEAP_DATA_VIEW: unknown;
+    let HEAP8: unknown;
+    let HEAPU8: unknown;
+    let HEAP16: unknown;
+    let HEAPU16: unknown;
+    let HEAP32: unknown;
+    let HEAPU32: unknown;
+    let HEAP64: unknown;
+    let HEAPU64: unknown;
+}
+interface WasmModule {
+}
+type EmbindString = ArrayBuffer | Uint8Array | Uint8ClampedArray | Int8Array | string;
+interface ClassHandle {
+    clone(): this;
+    delete(): void;
+    deleteLater(): this;
+    isAliasOf(other: ClassHandle): boolean;
+    isDeleted(): boolean;
+}
+interface VectorFloat extends ClassHandle {
+    get(_0: number): number | undefined;
+    push_back(_0: number): void;
+    resize(_0: number, _1: number): void;
+    set(_0: number, _1: number): boolean;
+    size(): number;
+}
+interface VectorMarker extends ClassHandle {
+    get(_0: number): Marker | undefined;
+    push_back(_0: Marker): void;
+    resize(_0: number, _1: Marker): void;
+    set(_0: number, _1: Marker): boolean;
+    size(): number;
+}
+interface VectorString extends ClassHandle {
+    get(_0: number): EmbindString | undefined;
+    push_back(_0: EmbindString): void;
+    resize(_0: number, _1: EmbindString): void;
+    set(_0: number, _1: EmbindString): boolean;
+    size(): number;
+}
+interface TvgEngineValue<T extends number> {
+    value: T;
+}
+type TvgEngine = TvgEngineValue<1> | TvgEngineValue<2> | TvgEngineValue<3>;
+interface ModeValue<T extends number> {
+    value: T;
+}
+type Mode$1 = ModeValue<1> | ModeValue<2> | ModeValue<3> | ModeValue<4>;
+interface FitValue<T extends number> {
+    value: T;
+}
+type Fit$1 = FitValue<1> | FitValue<3> | FitValue<2> | FitValue<4> | FitValue<5> | FitValue<6>;
+interface Layout$1 {
+    align: VectorFloat;
+    fit: Fit$1;
+}
+interface DotLottiePlayer extends ClassHandle {
+    activeAnimationId(): string;
+    activeThemeId(): string;
+    animationSize(): VectorFloat;
+    buffer(): unknown;
+    clear(): void;
+    config(): Config$1;
+    currentFrame(): number;
+    duration(): number;
+    getLayerBounds(_0: EmbindString): VectorFloat;
+    isComplete(): boolean;
+    isLoaded(): boolean;
+    isPaused(): boolean;
+    isPlaying(): boolean;
+    isStopped(): boolean;
+    loadAnimation(_0: EmbindString, _1: number, _2: number): boolean;
+    loadAnimationData(_0: EmbindString, _1: number, _2: number): boolean;
+    loadAnimationPath(_0: EmbindString, _1: number, _2: number): boolean;
+    loadDotLottieData(_0: EmbindString, _1: number, _2: number): boolean;
+    loadStateMachine(_0: EmbindString): boolean;
+    loadStateMachineData(_0: EmbindString): boolean;
+    loopCount(): number;
+    manifestString(): string;
+    markers(): VectorMarker;
+    pause(): boolean;
+    play(): boolean;
+    postBoolEvent(_0: boolean): number;
+    postNumericEvent(_0: number): number;
+    postPointerDownEvent(_0: number, _1: number): number;
+    postPointerEnterEvent(_0: number, _1: number): number;
+    postPointerExitEvent(_0: number, _1: number): number;
+    postPointerMoveEvent(_0: number, _1: number): number;
+    postPointerUpEvent(_0: number, _1: number): number;
+    postSetNumericContext(_0: EmbindString, _1: number): number;
+    postStringEvent(_0: EmbindString): number;
+    render(): boolean;
+    requestFrame(): number;
+    resetTheme(): boolean;
+    resize(_0: number, _1: number): boolean;
+    seek(_0: number): boolean;
+    segmentDuration(): number;
+    setConfig(_0: Config$1): void;
+    setFrame(_0: number): boolean;
+    setSlots(_0: EmbindString): boolean;
+    setStateMachineBooleanContext(_0: EmbindString, _1: boolean): boolean;
+    setStateMachineNumericContext(_0: EmbindString, _1: number): boolean;
+    setStateMachineStringContext(_0: EmbindString, _1: EmbindString): boolean;
+    setTheme(_0: EmbindString): boolean;
+    setThemeData(_0: EmbindString): boolean;
+    setViewport(_0: number, _1: number, _2: number, _3: number): boolean;
+    startStateMachine(): boolean;
+    stateMachineFrameworkSetup(): VectorString;
+    stop(): boolean;
+    stopStateMachine(): boolean;
+    totalFrames(): number;
+}
+interface Marker {
+    duration: number;
+    name: string;
+    time: number;
+}
+interface Config$1 {
+    autoplay: boolean;
+    backgroundColor: number;
+    layout: Layout$1;
+    loopAnimation: boolean;
+    marker: EmbindString;
+    mode: Mode$1;
+    segment: VectorFloat;
+    speed: number;
+    themeId: EmbindString;
+    useFrameInterpolation: boolean;
+}
+interface EmbindModule {
+    DotLottiePlayer: {
+        new (_0: Config$1, _1: TvgEngine, _2: number, _3: EmbindString): DotLottiePlayer;
+    };
+    Fit: {
+        Contain: FitValue<1>;
+        Cover: FitValue<3>;
+        Fill: FitValue<2>;
+        FitHeight: FitValue<5>;
+        FitWidth: FitValue<4>;
+        None: FitValue<6>;
+    };
+    Mode: {
+        Bounce: ModeValue<3>;
+        Forward: ModeValue<1>;
+        Reverse: ModeValue<2>;
+        ReverseBounce: ModeValue<4>;
+    };
+    TvgEngine: {
+        TvgEngineGl: TvgEngineValue<2>;
+        TvgEngineSw: TvgEngineValue<1>;
+        TvgEngineWg: TvgEngineValue<3>;
+    };
+    VectorFloat: {
+        new (): VectorFloat;
+    };
+    VectorMarker: {
+        new (): VectorMarker;
+    };
+    VectorString: {
+        new (): VectorString;
+    };
+    createDefaultConfig(): Config$1;
+    createDefaultLayout(): Layout$1;
+    transformThemeToLottieSlots(_0: EmbindString, _1: EmbindString): string;
+}
+type MainModule = WasmModule & typeof RuntimeExports & EmbindModule;
+
+/**
+ * Represents the different types of events that can be dispatched.
+ */
+type EventType = 'complete' | 'frame' | 'load' | 'loadError' | 'loop' | 'pause' | 'play' | 'stop' | 'destroy' | 'freeze' | 'unfreeze' | 'render' | 'ready';
+/**
+ * Maps an event type string to its respective event interface.
+ */
+type EventByType<T> = T extends 'complete' ? CompleteEvent : T extends 'frame' ? FrameEvent : T extends 'load' ? LoadEvent : T extends 'loadError' ? LoadErrorEvent : T extends 'loop' ? LoopEvent : T extends 'pause' ? PauseEvent : T extends 'play' ? PlayEvent : T extends 'stop' ? StopEvent : T extends 'destroy' ? DestroyEvent : T extends 'freeze' ? FreezeEvent : T extends 'unfreeze' ? UnfreezeEvent : T extends 'render' ? RenderEvent : T extends 'ready' ? ReadyEvent : never;
+/**
+ * Base interface for all events.
+ */
+interface BaseEvent {
+    type: EventType;
+}
+interface RenderEvent extends BaseEvent {
+    currentFrame: number;
+    type: 'render';
+}
+interface FreezeEvent extends BaseEvent {
+    type: 'freeze';
+}
+interface UnfreezeEvent extends BaseEvent {
+    type: 'unfreeze';
+}
+interface DestroyEvent extends BaseEvent {
+    type: 'destroy';
+}
+/**
+ * Event fired when a loop action occurs.
+ */
+interface LoopEvent extends BaseEvent {
+    loopCount: number;
+    type: 'loop';
+}
+/**
+ * Event fired during frame changes.
+ */
+interface FrameEvent extends BaseEvent {
+    currentFrame: number;
+    type: 'frame';
+}
+/**
+ * Event fired when a load action occurs.
+ */
+interface LoadEvent extends BaseEvent {
+    type: 'load';
+}
+/**
+ * Event fired when a loading error occurs.
+ */
+interface LoadErrorEvent extends BaseEvent {
+    error: Error;
+    type: 'loadError';
+}
+/**
+ * Event fired when a completion action occurs.
+ */
+interface CompleteEvent extends BaseEvent {
+    type: 'complete';
+}
+/**
+ * Event fired when a pause action occurs.
+ */
+interface PauseEvent extends BaseEvent {
+    type: 'pause';
+}
+/**
+ * Event fired when a play action occurs.
+ */
+interface PlayEvent extends BaseEvent {
+    type: 'play';
+}
+/**
+ * Event fired when a stop action occurs.
+ */
+interface StopEvent extends BaseEvent {
+    type: 'stop';
+}
+/**
+ * Event fired when a WASM module is initialized and ready.
+ */
+interface ReadyEvent extends BaseEvent {
+    type: 'ready';
+}
+/**
+ * Type representing all possible event types.
+ */
+type Event = LoopEvent | FrameEvent | LoadEvent | LoadErrorEvent | CompleteEvent | PauseEvent | PlayEvent | StopEvent | DestroyEvent | FreezeEvent | UnfreezeEvent | RenderEvent | ReadyEvent;
+interface EventListener<T extends EventType> {
+    (event: EventByType<T>): void;
+}
+/**
+ * Manages registration and dispatching of event listeners.
+ */
+declare class EventManager {
+    private readonly _eventListeners;
+    addEventListener<T extends EventType>(type: T, listener: EventListener<T>): void;
+    removeEventListener<T extends EventType>(type: T, listener?: EventListener<T>): void;
+    dispatch<T extends EventType>(event: EventByType<T>): void;
+    removeAllEventListeners(): void;
+}
+
+interface RenderConfig {
+    autoResize?: boolean;
+    devicePixelRatio?: number;
+    freezeOnOffscreen?: boolean;
+}
+type Mode = 'forward' | 'reverse' | 'bounce' | 'reverse-bounce';
+type Data = string | ArrayBuffer | Record<string, unknown>;
+type Fit = 'contain' | 'cover' | 'fill' | 'none' | 'fit-width' | 'fit-height';
+interface Layout {
+    align: [number, number];
+    fit: Fit;
+}
+interface Config {
+    autoplay?: boolean;
+    backgroundColor?: string;
+    canvas: HTMLCanvasElement;
+    data?: Data;
+    layout?: Layout;
+    loop?: boolean;
+    marker?: string;
+    mode?: Mode;
+    renderConfig?: RenderConfig;
+    segment?: [number, number];
+    speed?: number;
+    src?: string;
+    themeId?: string;
+    useFrameInterpolation?: boolean;
+}
+interface Manifest {
+    animations: Array<{
+        background?: string;
+        id: string;
+        initialTheme?: string;
+        themes?: string[];
+    }>;
+    generator?: string;
+    stateMachines?: Array<{
+        id: string;
+    }>;
+    themes?: Array<{
+        id: string;
+    }>;
+    version?: string;
+}
+
+interface WasmLoaderType {
+    load(): Promise<MainModule>;
+    setWasmUrl(url: string): void;
+}
+declare class DotLottieCommon {
+    private readonly _canvas;
+    private _context;
+    private readonly _eventManager;
+    private _animationFrameId;
+    private readonly _frameManager;
+    private _dotLottieCore;
+    private _wasmModule;
+    private _renderConfig;
+    private _isFrozen;
+    private _backgroundColor;
+    private readonly _pointerUpMethod;
+    private readonly _pointerDownMethod;
+    private readonly _pointerMoveMethod;
+    private readonly _pointerEnterMethod;
+    private readonly _pointerExitMethod;
+    private readonly _wasmLoader;
+    private readonly _renderer;
+    constructor(config: Config, wasmLoader: WasmLoaderType, renderer?: string);
+    private _dispatchError;
+    private _fetchData;
+    private _loadFromData;
+    private _loadFromSrc;
+    get activeAnimationId(): string | undefined;
+    get activeThemeId(): string | undefined;
+    get layout(): Layout | undefined;
+    get marker(): string | undefined;
+    get manifest(): Manifest | null;
+    get renderConfig(): RenderConfig;
+    get segment(): [number, number] | undefined;
+    get loop(): boolean;
+    get mode(): Mode;
+    get isFrozen(): boolean;
+    get backgroundColor(): string;
+    get autoplay(): boolean;
+    get useFrameInterpolation(): boolean;
+    get speed(): number;
+    get isReady(): boolean;
+    get isLoaded(): boolean;
+    get isPlaying(): boolean;
+    get isPaused(): boolean;
+    get isStopped(): boolean;
+    get currentFrame(): number;
+    get loopCount(): number;
+    get totalFrames(): number;
+    get duration(): number;
+    get segmentDuration(): number;
+    get canvas(): HTMLCanvasElement | OffscreenCanvas;
+    load(config: Omit<Config, 'canvas'>): void;
+    private _render;
+    private _draw;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    setFrame(frame: number): void;
+    setSpeed(speed: number): void;
+    setBackgroundColor(color: string): void;
+    setLoop(loop: boolean): void;
+    setUseFrameInterpolation(useFrameInterpolation: boolean): void;
+    addEventListener<T extends EventType>(type: T, listener: EventListener<T>): void;
+    removeEventListener<T extends EventType>(type: T, listener?: EventListener<T>): void;
+    destroy(): void;
+    freeze(): void;
+    unfreeze(): void;
+    resize(): void;
+    setSegment(startFrame: number, endFrame: number): void;
+    setMode(mode: Mode): void;
+    setRenderConfig(config: RenderConfig): void;
+    loadAnimation(animationId: string): void;
+    setMarker(marker: string): void;
+    markers(): Marker[];
+    setTheme(themeId: string): boolean;
+    resetTheme(): boolean;
+    setThemeData(themeData: string): boolean;
+    setSlots(slots: string): void;
+    setLayout(layout: Layout): void;
+    setViewport(x: number, y: number, width: number, height: number): boolean;
+    /**
+     * Static method to set WASM URL - this should be implemented by subclasses
+     * @param _url - The URL to set
+     */
+    static setWasmUrl(_url: string): void;
+    loadStateMachine(stateMachineId: string): boolean;
+    startStateMachine(): boolean;
+    stopStateMachine(): boolean;
+    private _getPointerPosition;
+    private _onPointerUp;
+    private _onPointerDown;
+    private _onPointerMove;
+    private _onPointerEnter;
+    private _onPointerLeave;
+    postPointerUpEvent(x: number, y: number): number | undefined;
+    postPointerDownEvent(x: number, y: number): number | undefined;
+    postPointerMoveEvent(x: number, y: number): number | undefined;
+    postPointerEnterEvent(x: number, y: number): number | undefined;
+    postPointerExitEvent(x: number, y: number): number | undefined;
+    getStateMachineListeners(): string[];
+    private _setupStateMachineListeners;
+    private _cleanupStateMachineListeners;
+    loadStateMachineData(stateMachineData: string): boolean;
+    animationSize(): {
+        height: number;
+        width: number;
+    };
+    setStateMachineBooleanContext(name: string, value: boolean): boolean;
+    setStateMachineNumericContext(name: string, value: number): boolean;
+    setStateMachineStringContext(name: string, value: string): boolean;
+    /**
+     * Get the bounds of a layer by its name
+     * @param layerName - The name of the layer
+     * @returns The bounds of the layer
+     *
+     * @example
+     * ```typescript
+     * // Draw a rectangle around the layer 'Layer 1'
+     * dotLottie.addEventListener('render', () => {
+     *   const boundingBox = dotLottie.getLayerBoundingBox('Layer 1');
+     *
+     *   if (boundingBox) {
+     *     const { x, y, width, height } = boundingBox;
+     *     context.strokeRect(x, y, width, height);
+     *   }
+     * });
+     * ```
+     */
+    getLayerBoundingBox(layerName: string): {
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+    } | undefined;
+    /**
+     * Transform theme to lottie slots
+     * @param theme - The theme data
+     * @param slots - The slots data
+     * @returns The transformed data
+     */
+    transformThemeToLottieSlots(theme: string, slots: string): string;
+}
+
+export { type BaseEvent as B, type Config as C, DotLottieCommon as D, type EventType as E, type FreezeEvent as F, type Layout as L, type Manifest as M, type PauseEvent as P, type RenderConfig as R, type StopEvent as S, type UnfreezeEvent as U, type WasmLoaderType as W, type Marker as a, type Mode as b, type EventListener as c, type RenderEvent as d, type DestroyEvent as e, type LoopEvent as f, type FrameEvent as g, type LoadEvent as h, type LoadErrorEvent as i, type CompleteEvent as j, type PlayEvent as k, type ReadyEvent as l, type Event as m, EventManager as n, type Data as o, type Fit as p };