@rive-app/canvas-lite 2.37.0 → 2.37.1

package/runtimeLoader.d.ts

@@ -0,0 +1,20 @@
+import * as rc from "./rive_advanced.mjs";
+export type RuntimeCallback = (rive: rc.RiveCanvas) => void;
+export declare class RuntimeLoader {
+    private static runtime;
+    private static isLoading;
+    private static callBackQueue;
+    private static rive;
+    private static wasmURL;
+    private constructor();
+    /**
+     * When true, performance.mark / performance.measure entries are emitted for
+     * WASM initialization.
+     */
+    static enablePerfMarks: boolean;
+    private static loadRuntime;
+    static getInstance(callback: RuntimeCallback): void;
+    static awaitInstance(): Promise<rc.RiveCanvas>;
+    static setWasmUrl(url: string): void;
+    static getWasmUrl(): string;
+}

package/utils/finalizationRegistry.d.ts

@@ -0,0 +1,94 @@
+import * as rc from "../rive_advanced.mjs";
+interface Finalizable {
+    unref: () => void;
+}
+declare class FileFinalizer implements Finalizable {
+    private _file;
+    selfUnref: boolean;
+    constructor(file: rc.File);
+    unref(): void;
+}
+declare class AssetWrapper implements rc.FinalizableTarget {
+    selfUnref: boolean;
+    unref(): void;
+}
+declare class ImageWrapper extends AssetWrapper {
+    private _nativeImage;
+    constructor(image: rc.Image);
+    get nativeImage(): rc.ImageInternal;
+    unref(): void;
+}
+declare class AudioWrapper extends AssetWrapper {
+    private _nativeAudio;
+    constructor(audio: rc.Audio);
+    get nativeAudio(): rc.AudioInternal;
+    unref(): void;
+}
+declare class FontWrapper extends AssetWrapper {
+    private _nativeFont;
+    constructor(font: rc.Font);
+    get nativeFont(): rc.FontInternal;
+    unref(): void;
+}
+export type AssetLoadCallbackWrapper = (asset: rc.FileAssetInternal, bytes: Uint8Array) => Boolean;
+declare class CustomFileAssetLoaderWrapper {
+    assetLoader: rc.CustomFileAssetLoader;
+    _assetLoaderCallback: AssetLoadCallbackWrapper;
+    constructor(runtime: rc.RiveCanvas, loaderCallback: AssetLoadCallbackWrapper);
+    loadContents(asset: rc.FileAsset, bytes: any): Boolean;
+}
+/**
+ * Rive class representing a FileAsset with relevant metadata fields to describe
+ * an asset associated wtih the Rive File
+ */
+declare class FileAssetWrapper {
+    _nativeFileAsset: rc.FileAssetInternal;
+    constructor(nativeAsset: rc.FileAssetInternal);
+    decode(bytes: Uint8Array): void;
+    get name(): string;
+    get fileExtension(): string;
+    get uniqueFilename(): string;
+    get isAudio(): boolean;
+    get isImage(): boolean;
+    get isFont(): boolean;
+    get cdnUuid(): string;
+    get nativeFileAsset(): rc.FileAssetInternal;
+}
+/**
+ * Rive class extending the FileAsset that exposes a `setRenderImage()` API with a
+ * decoded Image (via the `decodeImage()` API) to set a new Image on the Rive FileAsset
+ */
+declare class ImageAssetWrapper extends FileAssetWrapper {
+    setRenderImage(image: ImageWrapper): void;
+}
+/**
+ * Rive class extending the FileAsset that exposes a `setAudioSource()` API with a
+ * decoded Audio (via the `decodeAudio()` API) to set a new Audio on the Rive FileAsset
+ */
+declare class AudioAssetWrapper extends FileAssetWrapper {
+    setAudioSource(audio: AudioWrapper): void;
+}
+/**
+ * Rive class extending the FileAsset that exposes a `setFont()` API with a
+ * decoded Font (via the `decodeFont()` API) to set a new Font on the Rive FileAsset
+ */
+declare class FontAssetWrapper extends FileAssetWrapper {
+    setFont(font: FontWrapper): void;
+}
+declare const FinalizationRegistry: {
+    new (fn: Function): typeof FinalizationRegistry;
+    register<T extends rc.FinalizableTarget>(object: T, description: Finalizable): void;
+    unregister<T>(object: T): void;
+};
+declare class FakeFinalizationRegistry {
+    constructor(_: Function);
+    register(object: rc.FinalizableTarget): void;
+    unregister<T>(_: T): void;
+}
+declare const finalizationRegistry: {
+    new (fn: Function): typeof FinalizationRegistry;
+    register<T extends rc.FinalizableTarget>(object: T, description: Finalizable): void;
+    unregister<T>(object: T): void;
+} | FakeFinalizationRegistry;
+declare const createFinalization: <T extends Finalizable>(target: rc.FinalizableTarget, finalizable: T) => void;
+export { finalizationRegistry, createFinalization, Finalizable, ImageWrapper, AudioWrapper, FontWrapper, ImageAssetWrapper, AudioAssetWrapper, FontAssetWrapper, CustomFileAssetLoaderWrapper, FileAssetWrapper, FileFinalizer, };

package/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { registerTouchInteractions } from "./registerTouchInteractions";
+export { BLANK_URL, sanitizeUrl } from "./sanitizeUrl";
+export { Finalizable, ImageWrapper, AudioWrapper, FontWrapper, FileAssetWrapper, ImageAssetWrapper, AudioAssetWrapper, FontAssetWrapper, finalizationRegistry, CustomFileAssetLoaderWrapper, AssetLoadCallbackWrapper, FileFinalizer, createFinalization, } from "./finalizationRegistry";
+export { RiveFont } from "./riveFont";

package/utils/registerTouchInteractions.d.ts

@@ -0,0 +1,19 @@
+import * as rc from "../rive_advanced.mjs";
+export interface TouchInteractionsParams {
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+    artboard: rc.Artboard;
+    stateMachines: rc.StateMachineInstance[];
+    renderer: rc.Renderer;
+    rive: rc.RiveCanvas;
+    fit: rc.Fit;
+    alignment: rc.Alignment;
+    isTouchScrollEnabled?: boolean;
+    dispatchPointerExit?: boolean;
+    enableMultiTouch?: boolean;
+    layoutScaleFactor?: number;
+}
+/**
+ * Registers mouse move/up/down callback handlers on the canvas to send meaningful coordinates to
+ * the state machine pointer move/up/down functions based on cursor interaction
+ */
+export declare const registerTouchInteractions: ({ canvas, artboard, stateMachines, renderer, rive, fit, alignment, isTouchScrollEnabled, dispatchPointerExit, enableMultiTouch, layoutScaleFactor, }: TouchInteractionsParams) => () => void;

package/utils/riveFont.d.ts

@@ -0,0 +1,15 @@
+import type { FontWrapper } from "./finalizationRegistry";
+export type FallbackFontsCallback = (missingGlyph: number, weight: number) => FontWrapper | FontWrapper[] | null | undefined;
+export declare class RiveFont {
+    private static _fallbackFontCallback;
+    private constructor();
+    /**
+     * Set a callback to dynamically set a list of fallback fonts based on the missing glyph and/or style of the default font.
+     * Set null to clear the callback.
+     * @param fontCallback Callback to set a list of fallback fonts.
+     */
+    static setFallbackFontCallback(fontCallback: FallbackFontsCallback | null): void;
+    private static _fontToPtr;
+    private static _getFallbackPtr;
+    private static _wireFallbackProc;
+}

package/utils/sanitizeUrl.d.ts

@@ -0,0 +1,2 @@
+export declare const BLANK_URL = "about:blank";
+export declare function sanitizeUrl(url?: string): string;