vim-web 0.3.23 → 0.3.24

package/dist/types/ultra-viewer/viewer/rpcSafeClient.d.ts

@@ -0,0 +1,382 @@
+import { Box3, RGBA, RGBA32, Segment, Vector2, Vector3 } from "../utils/math3d";
+import { HitCheckResult } from "./marshal";
+import { MaterialHandle, RpcClient } from "./rpcClient";
+export type VimLoadingState = {
+    status: VimLoadingStatus;
+    progress: number;
+};
+export declare enum InputMode {
+    Orbit = "orbit",
+    Free = "free"
+}
+export type SceneSettings = {
+    toneMappingWhitePoint: number;
+    hdrScale: number;
+    hdrBackgroundScale: number;
+    hdrBackgroundSaturation: number;
+    backGroundBlur: number;
+    backgroundColor: RGBA;
+};
+export declare const defaultSceneSettings: SceneSettings;
+export declare enum VimLoadingStatus {
+    Unknown = 0,
+    Loading = 1,
+    Downloading = 2,
+    Done = 3,
+    FailedToDownload = 4,
+    FailedToLoad = 5
+}
+/**
+ * Provides safe, validated methods to interact with the RpcClient.
+ * This class wraps the raw RPC methods with input validation and batching support for large operations.
+ */
+export declare class RpcSafeClient {
+    private readonly rpc;
+    private readonly batchSize;
+    constructor(rpc: RpcClient, batchSize?: number);
+    /*******************************************************************************
+     * SCENE MANAGEMENT METHODS
+     * Methods for managing the overall scene, including initialization, lighting,
+     * and scene-wide settings.
+     ******************************************************************************/
+    /**
+     * Initializes and starts the scene with specified settings.
+     * @param settings - Optional partial scene settings to override defaults
+     * @remarks If no settings are provided, default values will be used
+     */
+    RPCStartScene(settings?: Partial<SceneSettings>): void;
+    /**
+     * Sets the lighting settings for the scene.
+     * @param settings - The lighting settings to apply
+     */
+    RPCSetLighting(settings: SceneSettings): void;
+    RPCLockIblRotation(lock: boolean): void;
+    /*******************************************************************************
+     * NODE VISIBILITY METHODS
+     * Methods for controlling node visibility, including show/hide, ghosting,
+     * and highlighting functionality.
+     ******************************************************************************/
+    /**
+     * Hides all nodes in a component, making the entire component invisible.
+     * @param componentHandle - The component to hide entirely
+     * @throws {Error} If the component handle is invalid
+     */
+    RPCHideAll(componentHandle: number): void;
+    /**
+     * Shows all nodes in a component, making the entire component visible.
+     * @param componentHandle - The component to show entirely
+     * @throws {Error} If the component handle is invalid
+     */
+    RPCShowAll(componentHandle: number): void;
+    /**
+     * Makes all nodes in a component semi-transparent (ghosted).
+     * @param componentHandle - The component to ghost entirely
+     * @throws {Error} If the component handle is invalid
+     */
+    RPCGhostAll(componentHandle: number): void;
+    /**
+     * Highlights all nodes in a component.
+     * @param componentHandle - The component to highlight entirely
+     * @throws {Error} If the component handle is invalid
+     */
+    RPCHighlightAll(componentHandle: number): void;
+    /**
+     * Hides specified nodes in a component, making them invisible.
+     * Large node arrays are automatically processed in batches.
+     * @param componentHandle - The component containing the nodes
+     * @param nodes - Array of node indices to hide
+     * @throws {Error} If the component handle is invalid or nodes array is invalid
+     */
+    RPCHide(componentHandle: number, nodes: number[]): void;
+    /**
+     * Shows specified nodes in a component, making them visible.
+     * Large node arrays are automatically processed in batches.
+     * @param componentHandle - The component containing the nodes
+     * @param nodes - Array of node indices to show
+     * @throws {Error} If the component handle is invalid or nodes array is invalid
+     */
+    RPCShow(componentHandle: number, nodes: number[]): void;
+    /**
+     * Makes specified nodes semi-transparent (ghosted) in a component.
+     * Large node arrays are automatically processed in batches.
+     * @param componentHandle - The component containing the nodes
+     * @param nodes - Array of node indices to ghost
+     * @throws {Error} If the component handle is invalid or nodes array is invalid
+     */
+    RPCGhost(componentHandle: number, nodes: number[]): void;
+    /**
+     * Highlights specified nodes in a component.
+     * Large node arrays are automatically processed in batches.
+     * @param componentHandle - The component containing the nodes
+     * @param nodes - Array of node indices to highlight
+     * @throws {Error} If the component handle is invalid or nodes array is invalid
+     */
+    RPCHighlight(componentHandle: number, nodes: number[]): void;
+    /*******************************************************************************
+     * TEXT AND UI METHODS
+     * Methods for creating and managing 3D text elements in the scene.
+     ******************************************************************************/
+    /**
+     * Creates a 3D text element in the scene.
+     * @param position - The world-space position for the text
+     * @param color - The color of the text
+     * @param text - The content to display
+     * @returns Promise resolving to the handle of the created text component
+     * @throws {Error} If the text is empty
+     */
+    RPCCreateText(position: Vector3, color: RGBA32, text: string): Promise<number>;
+    /**
+     * Destroys a text component, removing it from the scene.
+     * @param componentHandle - The handle of the text component to destroy
+     * @throws {Error} If the component handle is invalid
+     */
+    RPCDestroyText(componentHandle: number): void;
+    /*******************************************************************************
+     * CAMERA AND VIEW METHODS
+     * Methods for controlling camera position, movement, framing, and view settings.
+     ******************************************************************************/
+    /**
+     * Retrieves the current camera position and orientation.
+     * @returns Promise resolving to a segment representing the camera's current position and target
+     */
+    RPCGetCameraPosition(): Promise<Segment | undefined>;
+    /**
+     * Sets the camera position and orientation.
+     * @param segment - The desired camera position and target
+     * @param blendTime - Duration of the camera transition in seconds (non-negative)
+     * @throws {Error} If segment is invalid or blendTime is negative
+     */
+    RPCSetCameraPosition(segment: Segment, blendTime: number): void;
+    /**
+     * Calculates the bounding box for specified nodes in a component.
+     * Large node arrays are automatically processed in batches for better performance.
+     * @param componentHandle - The component containing the nodes
+     * @param nodes - Array of node indices to calculate bounds for
+     * @returns Promise resolving to the combined bounding box
+     * @throws {Error} If the component handle is invalid or nodes array is invalid
+     */
+    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<Box3 | undefined>;
+    private getBoundingBoxBatched;
+    /**
+     * Frames the camera to show all components in the scene.
+     * @param blendTime - Duration of the camera transition in seconds (non-negative)
+     * @returns Promise resolving to camera segment representing the final position
+     */
+    RPCFrameAll(blendTime: number): Promise<Segment | undefined>;
+    /**
+     * Frames a specific VIM component in the scene.
+     * @param componentHandle - The handle of the VIM component to frame
+     * @param blendTime - Duration of the camera transition in seconds (non-negative)
+     * @returns Promise resolving to camera segment representing the final position
+     * @throws {Error} If the component handle is invalid
+     */
+    RPCFrameVim(componentHandle: number, blendTime: number): Promise<Segment | undefined>;
+    /**
+     * Frames specific instances within a component. For large numbers of instances,
+     * automatically switches to bounding box framing for better performance.
+     * @param componentHandle - The component containing the instances
+     * @param nodes - Array of node indices to frame
+     * @param blendTime - Duration of the camera transition in seconds (non-negative)
+     * @returns Promise resolving to camera segment representing the final position
+     * @throws {Error} If the component handle is invalid or nodes array is empty
+     */
+    RPCFrameInstances(componentHandle: number, nodes: number[], blendTime: number): Promise<Segment | undefined>;
+    /**
+     * Frames the camera to show a specific bounding box.
+     * @param box - The bounding box to frame
+     * @param blendTime - Duration of the camera transition in seconds (non-negative)
+     * @throws {Error} If the box is invalid (min values must be less than max values)
+     */
+    RPCFrameBox(box: Box3, blendTime: number): Promise<Segment | undefined>;
+    /*******************************************************************************
+     * INPUT HANDLING METHODS
+     * Methods for handling user input including mouse, keyboard, and camera controls.
+     ******************************************************************************/
+    /**
+     * Sets the camera movement speed.
+     * @param speed - The desired movement speed (must be positive)
+     * @throws {Error} If speed is not positive
+     */
+    RPCSetMoveSpeed(speed: number): void;
+    RPCSetCameraMode(mode: InputMode): void;
+    /**
+     * Sets the viewer's aspect ratio.
+     * @param width - The width component of the aspect ratio
+     * @param height - The height component of the aspect ratio
+     * @throws {Error} If width or height are not positive integers
+     */
+    RPCSetAspectRatio(width: number, height: number): void;
+    /*******************************************************************************
+     * VIM FILE MANAGEMENT METHODS
+     * Methods for loading, unloading, and managing VIM files and components.
+     ******************************************************************************/
+    /**
+     * Loads a VIM file from the local filesystem.
+     * @param fileName - The path to the VIM file (supports file:// protocol)
+     * @returns Promise resolving to the handle of the loaded VIM component
+     * @throws {Error} If the filename is invalid or empty
+     */
+    RPCLoadVim(fileName: string): Promise<number>;
+    /**
+     * Loads a VIM file from a remote URL.
+     * @param url - The URL of the VIM file to load
+     * @returns Promise resolving to the handle of the loaded VIM component
+     * @throws {Error} If the URL is invalid
+     */
+    RPCLoadVimURL(url: string): Promise<number>;
+    /**
+     * Retrieves the current loading state and progress of a VIM component.
+     * @param componentHandle - The handle of the VIM component
+     * @returns Promise resolving to the current loading state and progress
+     * @throws {Error} If the component handle is invalid
+     */
+    RPCGetVimLoadingState(componentHandle: number): Promise<VimLoadingState>;
+    /**
+     * Unloads a VIM component and frees associated resources.
+     * @param componentHandle - The handle of the component to unload
+     * @throws {Error} If the component handle is invalid
+     */
+    RPCUnloadVim(componentHandle: number): void;
+    /**
+     * Clears the entire scene, removing all components and resetting to initial state.
+     */
+    RPCClearScene(): void;
+    /**
+     * Sets the color used for ghosted geometry.
+     * @param ghostColor - The RGBA color to use for ghosted elements
+     */
+    RPCSetGhostColor(ghostColor: RGBA): void;
+    /**
+     * Performs hit testing at a specified screen position.
+     * @param pos - Normalized screen coordinates (0-1, 0-1)
+     * @returns Promise resolving to hit test result if something was hit, undefined otherwise
+     */
+    RPCPerformHitTest(pos: Vector2): Promise<HitCheckResult | undefined>;
+    /**
+     * Sends a mouse button event to the viewer.
+     * @param position - The normalized screen coordinates (0-1, 0-1)
+     * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
+     * @param down - True if button is pressed down, false if released
+     * @throws {Error} If mouseButton is not a valid positive integer
+     */
+    RPCMouseButtonEvent(position: Vector2, mouseButton: number, down: boolean): void;
+    /**
+     * Sends a mouse double-click event to the viewer.
+     * @param position - The normalized screen coordinates (0-1, 0-1)
+     * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
+     * @throws {Error} If mouseButton is not a valid positive integer
+     */
+    RPCMouseDoubleClickEvent(position: Vector2, mouseButton: number): void;
+    /**
+     * Sends a mouse movement event to the viewer.
+     * @param position - The normalized screen coordinates (0-1, 0-1)
+     */
+    RPCMouseMoveEvent(position: Vector2): void;
+    /**
+     * Sends a mouse scroll wheel event to the viewer.
+     * @param scrollValue - The scroll amount (-1 to 1)
+     */
+    RPCMouseScrollEvent(scrollValue: number): void;
+    /**
+     * Sends a mouse selection event to the viewer.
+     * @param position - The normalized screen coordinates (0-1, 0-1)
+     * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
+     * @throws {Error} If mouseButton is not a valid positive integer
+     */
+    RPCMouseSelectEvent(position: Vector2, mouseButton: number): void;
+    /**
+     * Sends a keyboard event to the viewer.
+     * @param keyCode - The key code of the event
+     * @param down - True if key is pressed down, false if released
+     */
+    RPCKeyEvent(keyCode: number, down: boolean): void;
+    /*******************************************************************************
+     * MATERIAL MANAGEMENT METHODS
+     * Methods for creating and managing materials and material instances.
+     ******************************************************************************/
+    /**
+     * Creates multiple material instances with the same smoothness but different colors.
+     * Large color arrays are automatically processed in batches for better performance.
+     * @param materialHandle - The base material to create instances from
+     * @param smoothness - The smoothness value to apply (clamped between 0 and 1)
+     * @param colors - Array of colors for each material instance
+     * @returns Array of handles for the created material instances
+     * @throws {Error} If the material handle is invalid or smoothness is out of range
+     */
+    RPCCreateMaterialInstances(materialHandle: MaterialHandle, smoothness: number, colors: RGBA32[]): Promise<number[] | undefined>;
+    private createMaterialInstancesBatched;
+    /**
+     * Destroys multiple material instances, freeing associated resources.
+     * @param materialInstanceHandle - Array of handles for material instances to destroy
+     * @throws {Error} If any handle in the array is invalid
+     */
+    RPCDestroyMaterialInstances(materialInstanceHandle: number[]): void;
+    /**
+     * Sets material overrides for specific nodes in a component.
+     * Large arrays are automatically processed in batches for better performance.
+     * @param componentHandle - The component containing the nodes
+     * @param nodes - Array of node indices to override
+     * @param materialInstanceHandles - Array of material instance handles to apply (must match nodes length)
+     * @throws {Error} If arrays have different lengths or any handle is invalid
+     */
+    RPCSetMaterialOverrides(componentHandle: number, nodes: number[], materialInstanceHandles: number[]): void;
+    private setMaterialOverridesBatched;
+    /**
+     * Clears all material overrides for the specified component, restoring default materials.
+     * @param componentHandle - The unique identifier of the component
+     * @throws {Error} If the component handle is invalid or INVALID_HANDLE
+     */
+    RPCClearMaterialOverrides(componentHandle: number): void;
+    /*******************************************************************************
+     * DEBUG AND UTILITY METHODS
+     * Utility methods for debugging, error handling, and misc functionality.
+     ******************************************************************************/
+    /**
+     * Retrieves the current API version from the RPC client.
+     * @returns Promise resolving to the API version string
+     */
+    RPCGetAPIVersion(): Promise<string>;
+    /**
+     * Gets the API version of the underlying RPC client.
+     * @returns The API version string.
+     */
+    get API_VERSION(): string;
+    /**
+     * Retrieves the last error message from the RPC client.
+     * @returns Promise resolving to the last error message string
+     */
+    RPCGetLastError(): Promise<string>;
+    /**
+     * Pauses or resumes the rendering loop.
+     * @param pause - True to pause rendering, false to resume
+     */
+    RPCPauseRendering(pause: boolean): void;
+    /**
+     * Triggers a RenderDoc frame capture if RenderDoc is attached.
+     */
+    RPCTriggerRenderDocCapture(): void;
+    /**
+     * Shows axis-aligned bounding boxes (AABBs) for specified nodes with custom colors.
+     * Large arrays are automatically processed in batches for better performance.
+     * @param componentHandle - The component containing the nodes
+     * @param nodes - Array of node indices to show AABBs for
+     * @param colors - Array of colors for each AABB (must match nodes length)
+     * @throws {Error} If arrays have different lengths or component handle is invalid
+     */
+    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RGBA32[]): void;
+    /**
+     * Hides the axis-aligned bounding boxes (AABBs) for specified nodes.
+     * Large node arrays are automatically processed in batches.
+     * @param componentHandle - The component containing the nodes
+     * @param nodes - Array of node indices whose AABBs should be hidden
+     * @throws {Error} If the component handle is invalid or nodes array is invalid
+     */
+    RPCHideAABBs(componentHandle: number, nodes: number[]): void;
+    /**
+     * Hides all axis-aligned bounding boxes (AABBs) in a component.
+     * @param componentHandle - The component whose AABBs should be hidden
+     * @throws {Error} If the component handle is invalid
+     */
+    RPCHideAllAABBs(componentHandle: number): void;
+    private safeCall;
+}

package/dist/types/ultra-viewer/viewer/selection.d.ts

@@ -0,0 +1,94 @@
+import { Box3, Vector2, Vector3 } from "../utils/math3d";
+import { RpcSafeClient } from "./rpcSafeClient";
+import { Vim } from "./vim";
+import { IReadonlyVimCollection } from "./vimCollection";
+export interface IViewerSelection {
+    hitTest(pos: Vector2): Promise<HitTestResult | undefined>;
+    select(vim: Vim, node: number | number[]): void;
+    toggle(vim: Vim, node: number | number[]): void;
+    add(vim: Vim, node: number | number[]): void;
+    remove(vim: Vim, node: number | number[]): void;
+    clear(vim?: Vim): void;
+}
+/**
+ * Represents the result of a hit test operation.
+ */
+export type HitTestResult = {
+    /** The Vim instance that was hit */
+    vim: Vim;
+    /** The index of the node that was hit */
+    nodeIndex: number;
+    /** The 3D world position of the hit point */
+    worldPosition: Vector3;
+    /** The surface normal at the hit point */
+    worldNormal: Vector3;
+};
+/**
+ * Manages selection state of nodes across multiple VIM instances.
+ */
+export declare class ViewerSelection implements IViewerSelection {
+    private _rpc;
+    private _vims;
+    private _selectedNodes;
+    /**
+     * Creates a new ViewerSelection instance.
+     * @param rpc - RPC client for communication with the viewer.
+     * @param vims - Collection of VIM instances to manage.
+     */
+    constructor(rpc: RpcSafeClient, vims: IReadonlyVimCollection);
+    /**
+     * Gets the total number of selected nodes across all VIMs.
+     * @returns The total count of selected nodes.
+     */
+    get count(): number;
+    /**
+     * Performs a hit test at the specified screen position.
+     * @param pos - The screen position in 2D coordinates.
+     * @returns Promise resolving to hit test result or undefined if no hit.
+     */
+    hitTest(pos: Vector2): Promise<HitTestResult | undefined>;
+    /**
+     * Replaces the current selection with the specified node(s).
+     * Clears all previous selections across all VIMs.
+     * @param vim - The Vim instance to select nodes from.
+     * @param node - A single node index or array of node indices to select.
+     */
+    select(vim: Vim, node: number | number[]): void;
+    /**
+     * Toggles the selection state of the specified node(s).
+     * If a node is currently selected, it will be deselected, and vice versa.
+     * @param vim - The Vim instance containing the nodes.
+     * @param node - A single node index or array of node indices to toggle.
+     */
+    toggle(vim: Vim, node: number | number[]): void;
+    /**
+     * Adds the specified node(s) to the current selection.
+     * If a node is already selected, it remains selected.
+     * @param vim - The Vim instance containing the nodes.
+     * @param node - A single node index or array of node indices to add.
+     */
+    add(vim: Vim, node: number | number[]): void;
+    /**
+     * Removes the specified node(s) from the current selection.
+     * If a node is not selected, no action is taken for that node.
+     * @param vim - The Vim instance containing the nodes.
+     * @param node - A single node index or array of node indices to remove.
+     */
+    remove(vim: Vim, node: number | number[]): void;
+    /**
+     * Clears all selections across all VIMs or for a specific VIM.
+     * @param vim - Optional. If provided, only clears selections for the specified VIM.
+     */
+    clear(vim?: Vim): void;
+    /**
+     * Calculates the bounding box encompassing all selected nodes.
+     * @returns Promise resolving to a Box3 representing the bounds of all selected nodes,
+     *          or undefined if no nodes are selected or bounds cannot be calculated.
+     */
+    getBoundingBox(): Promise<Box3 | undefined>;
+    /**
+     * Cleans up resources and releases memory.
+     * Should be called when the selection manager is no longer needed.
+     */
+    dispose(): void;
+}

package/dist/types/ultra-viewer/viewer/socketClient.d.ts

@@ -0,0 +1,141 @@
+import * as Protocol from './protocol';
+import { Marshal } from './marshal';
+import { ILogger } from './logger';
+export type ClientState = ClientStateConnecting | ClientStateConnected | ClientStateDisconnected | ClientError;
+export type ClientError = ClientStateCompatibilityError | ClientStateConnectionError;
+export type ClientStateConnecting = {
+    status: 'connecting';
+};
+export type ClientStateConnected = {
+    status: 'connected';
+};
+export type ClientStateDisconnected = {
+    status: 'disconnected';
+};
+export type ClientStateCompatibilityError = {
+    status: 'error';
+    error: 'compatibility';
+    serverUrl: string;
+    serverVersion: string;
+    clientVersion: string;
+};
+export type ClientStateConnectionError = {
+    status: 'error';
+    error: 'connection';
+    serverUrl: string;
+};
+export declare enum FrameType {
+    VideoKeyFrame = 0,
+    VideoDeltaFrame = 1,
+    Disconnection = 2,
+    RPCResponse = 255,
+    CameraPose = 254
+}
+/**
+ * Messenger class responsible for handling WebSocket communication,
+ * including sending and receiving messages, managing connection state,
+ * and dispatching events.
+ */
+export declare class SocketClient {
+    private readonly _streamLogger;
+    private readonly _logger;
+    private _socket;
+    private readonly _queue;
+    private readonly _pendingRPCs;
+    private _rpcCallId;
+    private _reconnectTimeout;
+    private _connectionTimeout;
+    /**
+     * Callback function to handle incoming video frames.
+     * @param msg - The video frame message received from the server.
+     */
+    onVideoFrame: (msg: Protocol.VideoFrameMessage) => void;
+    private _state;
+    private _onStatusUpdate;
+    /**
+     * Event that is triggered when the connection status updates.
+     * @returns An event dispatcher for connection status updates.
+     */
+    get onStatusUpdate(): import("ste-simple-events").ISimpleEvent<ClientState>;
+    /**
+     * Gets the current connection status.
+     * @returns The current ClientStatus.
+     */
+    get state(): ClientState;
+    /**
+     * Updates the connection state and dispatches the status update event.
+     * @param state - The new connection state.
+     */
+    private updateState;
+    private _connectPromise;
+    private _connectingUrl;
+    /**
+     * Gets the URL to which the messenger is currently connecting or connected.
+     * @returns The WebSocket URL as a string, or undefined if not set.
+     */
+    get url(): string | undefined;
+    /**
+     * Constructs a new Messenger instance.
+     * @param logger - The logger for logging messages.
+     */
+    constructor(logger: ILogger);
+    /**
+     * Connects to a WebSocket server at the specified URL.
+     * @param url - The WebSocket URL to connect to.
+     * @returns A promise that resolves when the connection is established.
+     */
+    connect(url: string): Promise<void>;
+    /**
+     * Disconnects from the current WebSocket server.
+     */
+    disconnect(error?: ClientError): void;
+    /**
+     * Handles the disconnection logic, stopping logging and clearing the socket.
+     */
+    private _disconnect;
+    /**
+     * Clears the WebSocket event handlers and closes the connection if open.
+     */
+    private _clearSocket;
+    /**
+     * Handles incoming messages from the WebSocket server.
+     * @param event - The message event containing the data.
+     */
+    onMessage(event: MessageEvent): Promise<void>;
+    /**
+     * Handles RPC responses received from the server.
+     * @param buffer - The ArrayBuffer containing the response data.
+     */
+    private handleRPCResponse;
+    /**
+     * Handler for WebSocket 'open' event.
+     * @param _ - The event object (unused).
+     */
+    private _onOpen;
+    /**
+     * Handler for WebSocket 'close' event.
+     * @param _event - The event object.
+     */
+    private _onClose;
+    /**
+     * Sends binary data over the WebSocket connection.
+     * @param data - The ArrayBuffer containing the binary data to send.
+     */
+    sendBinary(data: ArrayBuffer): void;
+    /**
+     * Sends an RPC request and waits for a response.
+     * @param marshal - The Marshal containing the request data.
+     * @returns A promise that resolves with the response data.
+     */
+    sendRPCWithReturn(marshal: Marshal): Promise<Marshal>;
+    /**
+     * Sends an RPC request without expecting a response.
+     * @param marshal - The Marshal containing the request data.
+     */
+    sendRPC(marshal: Marshal): void;
+    private _clearPendingRPCs;
+    /**
+     * Disposes of the messenger, cleaning up resources and event handlers.
+     */
+    dispose(): void;
+}

package/dist/types/ultra-viewer/viewer/streamLogger.d.ts

@@ -0,0 +1,19 @@
+import type { VideoFrameMessage } from './protocol';
+import { ILogger } from './logger';
+export declare class StreamLogger {
+    private readonly _logger;
+    private _frameCount;
+    private _dataLengthSum;
+    private _id;
+    constructor(logger: ILogger);
+    /**
+     * Starts logging the stream metrics.
+     */
+    startLoggging(): void;
+    /**
+     * Stops logging the stream metrics.
+     */
+    stopLogging(): void;
+    onFrame(frameMsg: VideoFrameMessage): void;
+    private logMetrics;
+}

package/dist/types/ultra-viewer/viewer/streamRenderer.d.ts

@@ -0,0 +1,7 @@
+export declare class WebGLRenderer {
+    private readonly canvas;
+    private readonly ctx;
+    constructor(canvas: OffscreenCanvas);
+    draw(frame: globalThis.VideoFrame): void;
+    clear(): void;
+}