@rive-app/webgl2-threads 0.0.0-stage → 2.47.0

package/runtimeLoader.d.ts

@@ -0,0 +1,48 @@
+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 static wasmFallbackURL;
+    private static wasmBinary;
+    private static wasmThreadsURL;
+    private static triedThreads;
+    private static errorCallbackQueue;
+    private constructor();
+    /**
+     * When true, performance.mark / performance.measure entries are emitted for
+     * WASM initialization.
+     */
+    static enablePerfMarks: boolean;
+    private static notifyError;
+    private static loaded;
+    private static loadRuntime;
+    private static loadUnthreaded;
+    static getInstance(callback: RuntimeCallback, onError?: (error: Error) => void): void;
+    static awaitInstance(): Promise<rc.RiveCanvas>;
+    static setWasmUrl(url: string): void;
+    static getWasmUrl(): string;
+    /**
+     * Sets the URL used as a fallback when the primary WASM URL fails to load.
+     * Pass `null` to disable the fallback entirely.
+     *
+     * Defaults to pulling from the jsdelivr CDN.
+     */
+    static setWasmFallbackUrl(url: string | null): void;
+    static getWasmFallbackUrl(): string | null;
+    /**
+     * Sets the URL of the threaded build's wasm, which
+     * `@rive-app/webgl2-threads` loads on a cross origin isolated page. Pass
+     * `null` to always load the build without threads. Other packages have no
+     * threaded build and ignore it.
+     *
+     * Defaults to pulling from the unpkg CDN.
+     */
+    static setWasmThreadsUrl(url: string | null): void;
+    static getWasmThreadsUrl(): string | null;
+    static setWasmBinary(value: ArrayBuffer | null): void;
+    static getWasmBinary(): ArrayBuffer | null;
+}

package/semantics/accessibilityOverlay.d.ts

@@ -0,0 +1,272 @@
+import type * as rc from "../rive_advanced.mjs";
+import type { SemanticTreeModel } from "./semanticTreeModel";
+import { SemanticActionType, RiveSemanticsOptions } from "./types";
+export interface AccessibilityOverlayOptions {
+    canvas: HTMLCanvasElement;
+    /** Unique string per Rive instance (used for prefixed IDs). */
+    instanceId: string;
+    /** Optional options for controlling semantic tree behavior and rendering */
+    semanticsOptions: RiveSemanticsOptions;
+    /** Callback to fire a semantic action back into the state machine. */
+    fireAction: (nodeId: number, actionType: SemanticActionType) => void;
+    /** Callback when AT focuses a semantic node (routes to SemanticManager::requestFocus). */
+    requestFocus: (nodeId: number) => void;
+    /** Callback when AT focus leaves a semantic node. */
+    clearFocus: () => void;
+    /**
+     * When false (default), the overlay only moves focus while focus is already
+     * inside Rive (overlay or canvas); when true it may also pull focus from outside Rive.
+     */
+    allowFocusInterrupt?: boolean;
+    /**
+     * True while a text input session holds DOM focus on the hidden text-input proxy.
+     * Defaults to false when text input isn't wired.
+     */
+    isEditingHostFocused?: () => boolean;
+}
+/**
+ * Indication of what changed since the last overlay update.
+ *
+ * - `semanticChanged` — semantic tree content/structure changed; attributes,
+ *   DOM order, and stale removal need reconciling.
+ * - `nodeGeometryChanged` — node bounds changed in the tree model.
+ * - `layoutChanged` — canvas size/position changed (or the transform container
+ *   hasn't been created yet); the artboard→canvas transform must be recomputed.
+ */
+export interface OverlayChange {
+    semanticChanged: boolean;
+    nodeGeometryChanged: boolean;
+    layoutChanged: boolean;
+}
+/**
+ * What the overlay needs from the element capturing text for a focused Rive text
+ * field (the hidden text-input proxy).
+ */
+export interface EditingHost {
+    /** Apply accessibility attributes; a null value removes that attribute. */
+    decorate(attrs: Record<string, string | null>): void;
+    resetDecoration(): void;
+    /** Capture as a secure (password) field while standing in for an obscured one. */
+    setSecure(secure: boolean): void;
+    hasDomFocus(): boolean;
+}
+/**
+ * Creates and manages an invisible DOM tree overlaying a Rive canvas. This is for
+ * screen readers to discover and interact with the Rive content.
+ *
+ * Each semantic node in the {@link SemanticTreeModel} gets a corresponding
+ * DOM element with appropriate ARIA role, states, and action handlers so
+ * assistive technologies (i.e. screen readers) can discover
+ * and interact with the Rive content.
+ *
+ * Each node receives a prefixed ID (`id=rive-{instanceId}-sem-{nodeId}`) to avoid host-page ID collisions.
+ * The nodeID is Rive's semantic node ID from core runtime.
+ * Each node is styled with `pointer-events: none`. Interactive nodes can receive
+ * programmatic focus and keydown events without entering the browser Tab order.
+ */
+export declare class AccessibilityOverlay {
+    private container;
+    private canvas;
+    private semanticsOptions;
+    private elements;
+    /** Visually-hidden description spans keyed by node ID, referenced by aria-describedby. */
+    private descElements;
+    private instanceId;
+    private fireAction;
+    private requestFocus;
+    private clearFocus;
+    private lastSemanticVersion;
+    private lastGeometryVersion;
+    /** Text elements whose fit-scale needs recomputing, batched per update (see flushTextGeometry). */
+    private pendingTextGeometry;
+    /** Last measured box-size|text key per text element, to skip redundant re-measures. */
+    private textGeometryKeys;
+    /** Node data last passed to applyAttributes per element; see {@link setEditingHostNode}. */
+    private appliedNodes;
+    private lastCanvasPositioning;
+    /**
+     * Set when a ResizeObserver/window-resize signals the canvas geometry may have
+     * changed, cleared once the transform is re-synced. Lets {@link needsUpdate}
+     * report geometry changes without a per-frame `getBoundingClientRect()` reflow.
+     * Starts true so the first update computes the transform.
+     */
+    private _geometryDirty;
+    /** True while reconciling the DOM (reserved for future focus-sync guards). */
+    private isUpdating;
+    /** See {@link AccessibilityOverlayOptions.allowFocusInterrupt}. */
+    private allowFocusInterrupt;
+    /** See {@link AccessibilityOverlayOptions.isEditingHostFocused}. */
+    private isEditingHostFocused;
+    /** Node whose element the editing host stands in for, or null. */
+    private editingHostNodeId;
+    /** Semantic version last folded into the editing host's decoration. */
+    private editingHostSemanticVersion;
+    /**
+     * Single child div of the overlay container that carries the artboard→CSS
+     * transform. All semantic node elements are children of this div and express
+     * their positions in raw artboard-space coordinates. The CSS transform on
+     * this container maps artboard units to CSS pixels in one GPU pass — no
+     * per-node matrix multiplication required.
+     */
+    private transformContainer;
+    private _artboardBounds;
+    private repositionTimer;
+    private canvasResizeObserver;
+    private parentResizeObserver;
+    /**
+     * Detects canvas *position* drift. See {@link observePosition}.
+     */
+    private positionObserver;
+    private readonly _onWindowResize;
+    constructor(options: AccessibilityOverlayOptions);
+    /**
+     * Hide the stood-in node's element (no duplicate textbox for AT); re-derive the previous
+     * one's aria-hidden.
+     */
+    setEditingHostNode(nodeId: number | null): void;
+    /**
+     * Describe the focused text field on the host and hide its element; no-op unless
+     * semantics changed.
+     * @param force - apply even if semantics are unchanged (session start).
+     */
+    syncEditingHost(tree: SemanticTreeModel, host: EditingHost, force: boolean): void;
+    /** True while the editing host stands in for a node's element. */
+    hasEditingHost(): boolean;
+    /**
+     * Undo the stand-in; if the host still has DOM focus, move it to the focused node's
+     * element so AT announces it.
+     */
+    releaseEditingHost(tree: SemanticTreeModel | null, host: EditingHost | null): void;
+    /** Move DOM focus onto a node's element. No-op for a node with no element. */
+    focusNodeElement(nodeId: number): void;
+    private focusElementInPlace;
+    getSemanticOverlayContainer(): HTMLDivElement;
+    private attachPositionObservers;
+    /**
+     * Arms an IntersectionObserver whose root box is bounded to the canvas, so it
+     * fires when the canvas moves relative to the viewport — position drift that
+     * no ResizeObserver reports. Lets us re-sync the overlay container on a move
+     * instead of recalculating the canvas bounding box every frame.
+     */
+    private observePosition;
+    private scheduleReposition;
+    /** Returns true when the container's size changed (node transforms need recomputing). */
+    private syncContainerGeometry;
+    /**
+     * Re-align the container right before focusing one of its elements. The position
+     * observer re-syncs after scrolling on a throttle; focusing an element while the
+     * container is stale would make the browser scroll the page to where it sits.
+     */
+    private syncContainerBeforeFocus;
+    private createContainer;
+    /**
+     * Returns what changed since the last update, or null if nothing changed.
+     *
+     * Callers use this to avoid recomputing the (relatively expensive)
+     * artboard→canvas transform on frames where only node bounds changed in the
+     * tree: the transform only needs recomputing when `layoutChanged` is true.
+     */
+    needsUpdate(tree: SemanticTreeModel): OverlayChange | null;
+    /**
+     * Update the overlay DOM to reflect the current state of the semantic tree.
+     * Call once per frame after `applyDiff` when {@link needsUpdate} reports a
+     * change, when layout/transform inputs are dirty, or when a fresh
+     * `forwardMat` is supplied (even if the tree versions are unchanged).
+     *
+     * @param tree           The in-memory semantic tree model
+     * @param forwardMat     Artboard→canvas-pixel transform from `computeAlignment`,
+     *                       or null to reuse the existing CSS transform on the
+     *                       transform container
+     * @param dpr            Device pixel ratio used for the canvas backing store
+     * @param artboardBounds The artboard's own bounding rectangle
+     */
+    update(tree: SemanticTreeModel, forwardMat: rc.Mat2D | null, dpr: number, artboardBounds: rc.AABB, change?: OverlayChange | null): void;
+    private performUpdate;
+    /** Remove the overlay from the DOM entirely. */
+    destroy(): void;
+    /**
+     * Reconcile a parent DOM element's children with an ordered list of
+     * semantic node IDs. Creates, updates, and reorders elements as needed.
+     *
+     * Node positions are expressed in artboard-space coordinates. The CSS
+     * transform on the transform container maps artboard units to CSS pixels,
+     * so no per-node matrix multiplication is required here.
+     *
+     * @param parentArtboardLeft  Absolute artboard minX of the parent node (0 for roots)
+     * @param parentArtboardTop   Absolute artboard minY of the parent node (0 for roots)
+     */
+    private rebuildChildren;
+    /**
+     * Reposition only the subtrees whose bounds changed in the latest diff.
+     * Descendants are included because node CSS positions are parent-relative.
+     */
+    private updateGeometryForChangedNodes;
+    private updateNodeGeometrySubtree;
+    /**
+     * Whether the overlay may move focus now. Following focus already inside this
+     * instance is always allowed; pulling it in from the host page is gated behind
+     * allowFocusInterrupt (from the Rive class).
+     */
+    private canMoveFocus;
+    /**
+     * Move focus into a newly appeared modal/alert dialog so screen readers
+     * announce and read its content (web ATs don't auto-enter a freshly mounted
+     * dialog). Skips when focus can't move (see canMoveFocus) or a descendant
+     * already holds it. The dialog's aria-modal keeps focus trapped inside.
+     */
+    private autoFocusDialogOnAppear;
+    /**
+     * Resolve the element assistive technologies (AT) should focus on appearance. Walks the subtree
+     * depth-first and returns the first focusable node's host element, else the
+     * inner <span> of the first labeled leaf. Container and unlabeled nodes are
+     * descended into but never focused. Returns null if nothing qualifies.
+     */
+    private routeDefaultFocusTarget;
+    /** Shared `id` prefix for all semantic node elements of this instance. */
+    private get nodeIdPrefix();
+    /** Recover the semantic node ID from an overlay element, or null. */
+    private nodeIdFromElement;
+    private createElement;
+    /**
+     * Wire arrow-key roving focus for a group member (tab, radio). Arrow keys
+     * move focus to the next/previous member (wrapping), optionally Home/End jump
+     * to first/last, and the newly focused member receives a tap action.
+     */
+    private attachRovingNav;
+    private attachActionHandlers;
+    private isAriaHidden;
+    private applyAttributes;
+    /**
+     * Positions an element in artboard-space coordinates relative to its parent.
+     *
+     * Node bounds stay in raw artboard units — the CSS `transform: matrix(...)`
+     * on the transform container maps artboard units to CSS pixels in one GPU
+     * pass. No per-node forwardMat multiplication or DPR division needed here.
+     *
+     * Round to whole artboard units before comparing to avoid triggering AX
+     * layout notifications from sub-unit floating-point animation jitter.
+     */
+    private applyPosition;
+    /**
+     * Scale each queued text span to fit its layout box, batched so a frame
+     * pays at most one synchronous layout: all measurement-reset writes first,
+     * then all rect reads, then all transform writes. Interleaving
+     * write→read→write per node would force a reflow per text node instead.
+     *
+     * Nodes whose box size and text are unchanged since the last pass are
+     * skipped entirely (their existing transform is still correct — the scale
+     * is a ratio of two rects, so ancestor transform changes cancel out).
+     */
+    private flushTextGeometry;
+    /**
+     * Creates (on first call) and updates the artboard-space transform container.
+     *
+     * The container is sized to the artboard dimensions and carries a CSS
+     * `transform: matrix(...)` that maps artboard coordinates to the canvas's CSS box
+     * (forwardMat in backing-store pixels, scaled by CSS size / backing-store size). All semantic
+     * node elements are children of this container and use raw artboard
+     * coordinates as their CSS `left/top/width/height`, so the CSS compositor
+     * applies the artboard→screen mapping in one pass.
+     */
+    private syncTransformContainer;
+}

package/semantics/claimedKeyEvents.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Marks a key event as handled by a semantic overlay widget (and prevents its
+ * default), so the Rive keyboard handler leaves it alone. A plain
+ * `defaultPrevented` check can't tell these apart from host-page handlers.
+ */
+export declare function claimKeyEvent(event: Event): void;
+export declare function isKeyEventClaimed(event: Event): boolean;

package/semantics/index.d.ts

@@ -0,0 +1,5 @@
+export { SemanticTreeModel } from "./semanticTreeModel";
+export { AccessibilityOverlay } from "./accessibilityOverlay";
+export type { AccessibilityOverlayOptions } from "./accessibilityOverlay";
+export { SemanticRole, SemanticState, SemanticCheckState, SemanticTrait, SemanticActionType, SemanticMode, CHECK_STATE_OFFSET, CHECK_STATE_MASK, checkStateOf, hasState, hasTrait, roleName, stateNames, traitNames, } from "./types";
+export type { SemanticsDiffNode, SemanticsDiff, SemanticNodeData, RiveSemanticsOptions, } from "./types";

package/semantics/semanticTreeModel.d.ts

@@ -0,0 +1,66 @@
+import type { SemanticsDiff, SemanticNodeData } from "./types";
+/**
+ * Maintains an in-memory semantic tree built from incremental
+ * {@link SemanticsDiff} updates received each frame from the WASM runtime.
+ *
+ * Processing order within {@link applyDiff} follows the contract defined in
+ * `semantic_snapshot.hpp`: removed → added → moved → childrenUpdated →
+ * updatedSemantic → updatedGeometry.
+ */
+export declare class SemanticTreeModel {
+    private _nodesById;
+    private _roots;
+    private _semanticVersion;
+    private _geometryVersion;
+    private _geometryChangedIds;
+    private _semanticChangedIds;
+    get nodeCount(): number;
+    /** Bumped when semantic content or tree structure changes. */
+    get semanticVersion(): number;
+    /** Bumped when node bounds change without a semantic/structural change. */
+    get geometryVersion(): number;
+    /** Node IDs whose bounds changed in the most recent {@link applyDiff}. */
+    get geometryChangedIds(): ReadonlySet<number>;
+    /**
+     * Node IDs whose semantic fields (role/label/value/hint/flags/headingLevel)
+     * changed in the most recent {@link applyDiff}. Structural changes (moves,
+     * child reorders, removals) bump {@link semanticVersion} but don't mark
+     * nodes here — element attributes don't depend on tree position.
+     */
+    get semanticChangedIds(): ReadonlySet<number>;
+    /** Root node IDs in sibling order. */
+    get roots(): readonly number[];
+    /** Look up a node by its ID, or undefined if not in the tree. */
+    nodeById(id: number): SemanticNodeData | undefined;
+    /** The node with SemanticState.Focused, or undefined. */
+    focusedNode(): SemanticNodeData | undefined;
+    /** Current index of a node among its siblings (or roots), or -1 if absent. */
+    private siblingIndexOf;
+    /** Detach a node from its current parent (or from roots). */
+    private detach;
+    /** Attach a node under a parent at a given sibling index (or as root). */
+    private attach;
+    /** Recursively remove a node and all descendants. */
+    private removeSubtree;
+    /**
+     * Apply an incremental diff to the tree. Bumps version counters and notifies
+     * listeners only when the tree actually changed.
+     *
+     * No-op diffs (field values identical to current model) do not bump
+     * versions — the native side guards against emitting these, but applyDiff
+     * defends its subscribers regardless.
+     */
+    applyDiff(diff: SemanticsDiff): void;
+    private _debug;
+    /** Enable/disable debug logging of diffs to the console. */
+    set debug(enabled: boolean);
+    private logDiff;
+    /**
+     * Returns every node in depth-first order, paired with its depth level.
+     * Useful for debug logging / rendering a flat list.
+     */
+    flattened(): Array<{
+        depth: number;
+        node: SemanticNodeData;
+    }>;
+}

package/semantics/types.d.ts

@@ -0,0 +1,107 @@
+import type { SemanticsDiffNode, SemanticsDiff } from "../rive_advanced.mjs";
+export type { SemanticsDiffNode, SemanticsDiff, };
+export declare const SemanticRole: {
+    readonly none: 0;
+    readonly button: 1;
+    readonly link: 2;
+    readonly checkbox: 3;
+    readonly switchControl: 4;
+    readonly slider: 5;
+    readonly textField: 6;
+    readonly text: 7;
+    readonly image: 8;
+    readonly group: 9;
+    readonly list: 10;
+    readonly listItem: 11;
+    readonly tab: 12;
+    readonly tabList: 13;
+    readonly dialog: 14;
+    readonly alertDialog: 15;
+    readonly radioGroup: 16;
+    readonly radioButton: 17;
+};
+export type SemanticRole = (typeof SemanticRole)[keyof typeof SemanticRole];
+export declare const SemanticState: {
+    readonly None: 0;
+    readonly Expanded: number;
+    readonly Selected: number;
+    readonly Toggled: number;
+    readonly Required: number;
+    readonly Disabled: number;
+    readonly Focused: number;
+    readonly Hidden: number;
+    readonly LiveRegion: number;
+    readonly ReadOnly: number;
+    readonly Modal: number;
+    readonly Obscured: number;
+    readonly Multiline: number;
+};
+export declare function hasState(flags: number, state: number): boolean;
+export declare const SemanticCheckState: {
+    readonly Unchecked: 0;
+    readonly Checked: 1;
+    readonly Mixed: 2;
+};
+export type SemanticCheckState = (typeof SemanticCheckState)[keyof typeof SemanticCheckState];
+/** Bit offset of the check field within stateFlags. */
+export declare const CHECK_STATE_OFFSET = 2;
+/** Mask of the check field within stateFlags. */
+export declare const CHECK_STATE_MASK: number;
+/**
+ * Decodes the check field out of `flags`. The field is two bits. Returns 0, 1, or 2
+ * per the mapping in SemanticCheckState.
+ */
+export declare function checkStateOf(flags: number): SemanticCheckState;
+/**
+ * Controls when the instance builds semantic trees and accessibility overlays.
+ *
+ * - `disabled`: no semantics work.
+ * - `enabled`: semantics and overlay are active immediately after load.
+ */
+export declare const SemanticMode: {
+    readonly Disabled: "disabled";
+    readonly Enabled: "enabled";
+};
+export type SemanticMode = (typeof SemanticMode)[keyof typeof SemanticMode];
+export interface RiveSemanticsOptions {
+    /**
+     * aria-label for the semantic DOM container element
+     */
+    riveCanvasLabel?: string;
+}
+export declare const SemanticTrait: {
+    readonly None: 0;
+    readonly Expandable: number;
+    readonly Selectable: number;
+    readonly Checkable: number;
+    readonly Toggleable: number;
+    readonly Requirable: number;
+    readonly Enablable: number;
+    readonly Focusable: number;
+};
+export declare function hasTrait(flags: number, trait: number): boolean;
+export declare const SemanticActionType: {
+    readonly tap: 0;
+    readonly increase: 1;
+    readonly decrease: 2;
+};
+export type SemanticActionType = (typeof SemanticActionType)[keyof typeof SemanticActionType];
+export interface SemanticNodeData {
+    readonly id: number;
+    parentId: number;
+    role: number;
+    label: string;
+    value: string;
+    hint: string;
+    stateFlags: number;
+    traitFlags: number;
+    headingLevel: number;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    children: number[];
+}
+export declare function roleName(role: number): string;
+export declare function stateNames(flags: number): string;
+export declare function traitNames(flags: number): string;

package/utils/canvasOffset.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Canvas offset within its offsetParent, minus the scroll of ancestors in between (they
+ * move the canvas, not absolutely positioned siblings).
+ */
+export declare function canvasOffset(canvas: HTMLElement): {
+    top: number;
+    left: number;
+};

package/utils/finalizationRegistry.d.ts

@@ -0,0 +1,98 @@
+import * as rc from "../rive_advanced.mjs";
+interface Finalizable {
+    unref: () => void;
+}
+declare class FileFinalizer implements Finalizable {
+    private _file;
+    private _session;
+    selfUnref: boolean;
+    constructor(file: rc.File, session?: rc.DeferredSession | null);
+    unref(): void;
+    release(): 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;
+    _session: rc.DeferredSession | null;
+    constructor(runtime: rc.RiveCanvas, loaderCallback: AssetLoadCallbackWrapper, session?: rc.DeferredSession | null);
+    loadContents(asset: rc.FileAsset, bytes: any): false | 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;
+    _session: rc.DeferredSession | null;
+    constructor(nativeAsset: rc.FileAssetInternal, session?: rc.DeferredSession | null);
+    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,6 @@
+export { registerTouchInteractions } from "./registerTouchInteractions";
+export { KeyboardInteractions, FocusSessionState } from "./registerKeyboardInteractions";
+export type { KeyboardInteractionsParams } from "./registerKeyboardInteractions";
+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";