vim-web 0.6.0-dev.3 → 0.6.0-dev.5

package/dist/types/core-viewers/ultra/socketClient.d.ts

@@ -1,153 +0,0 @@
-import { ILogger } from './logger';
-import * as Protocol from './protocol';
-import { Marshal, ReadMarshal } from './rpcMarshal';
-import { Segment } from './rpcTypes';
-export declare const DEFAULT_LOCAL_SERVER_URL = "ws://localhost:8123";
-export type ConnectionSettings = {
-    url?: string;
-    retries?: number;
-    timeout?: number;
-    retryDelay?: number;
-};
-export type ClientState = ClientStateConnecting | ClientStateConnected | ClientStateDisconnected | ClientStateValidating | ClientError;
-export type ClientError = ClientStateCompatibilityError | ClientStateConnectionError | ClientStreamError;
-export type ClientStateConnecting = {
-    status: 'connecting';
-};
-export type ClientStateValidating = {
-    status: 'validating';
-};
-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 type ClientStreamError = {
-    status: 'error';
-    error: 'stream';
-    serverUrl: string;
-    details: string;
-};
-/**
- * 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 _pendingRPCs;
-    private _rpcCallId;
-    private _reconnectTimeout;
-    private _connectionTimeout;
-    private _validateConnection;
-    /**
-     * Callback function to handle incoming video frames.
-     * @param msg - The video frame message received from the server.
-     */
-    onVideoFrame: (msg: Protocol.VideoFrameMessage) => void;
-    onCameraPose: (msg: Segment) => void;
-    private _state;
-    private _onStatusUpdate;
-    private _connectPromise;
-    private _connectionSettings;
-    /**
-     * 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;
-    /**
-     * 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.
-     * @param checks - checks to perform before returning connection.
-     */
-    constructor(logger: ILogger, validateConnection: () => Promise<ClientError | undefined>);
-    /**
-     * 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(settings: ConnectionSettings): Promise<boolean>;
-    /**
-     * 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<ReadMarshal>;
-    /**
-     * 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/core-viewers/ultra/streamLogger.d.ts

@@ -1,19 +0,0 @@
-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/core-viewers/ultra/streamRenderer.d.ts

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

package/dist/types/core-viewers/ultra/viewer.d.ts

@@ -1,139 +0,0 @@
-import type { ISimpleEvent } from 'ste-simple-events';
-import type { InputHandler } from '../shared';
-import { ICamera } from './camera';
-import { ColorManager } from './colorManager';
-import { IDecoder } from './decoder';
-import { type ILoadRequest } from './loadRequest';
-import { ILogger } from './logger';
-import { IUltraRaycaster } from './raycaster';
-import { IRenderer } from './renderer';
-import { RpcSafeClient, VimSource } from './rpcSafeClient';
-import { SectionBox } from './sectionBox';
-import { ISelection } from './selection';
-import { ClientState, ConnectionSettings } from './socketClient';
-import { IViewport } from './viewport';
-import { Vim } from './vim';
-import { IReadonlyVimCollection } from './vimCollection';
-export declare const INVALID_HANDLE = 4294967295;
-/**
- * The main Viewer class responsible for managing VIM files,
- * handling connections, and coordinating various components like the camera, decoder, and inputs.
- */
-export declare class Viewer {
-    /**
-     * The type of the viewer, indicating it is a WebGL viewer.
-     * Useful for distinguishing between different viewer types in a multi-viewer application.
-     */
-    readonly type = "ultra";
-    private readonly _decoder;
-    private readonly _socketClient;
-    private readonly _input;
-    private readonly _logger;
-    private readonly _canvas;
-    private readonly _renderer;
-    private readonly _viewport;
-    private readonly _camera;
-    private readonly _selection;
-    private readonly _raycaster;
-    private readonly _vims;
-    private _disposed;
-    /**
-     * The camera API for controlling camera movements and settings.
-     */
-    get camera(): ICamera;
-    /**
-     * The RPC client for making remote procedure calls.
-     */
-    readonly rpc: RpcSafeClient;
-    /**
-     * The input API for handling user input events.
-     */
-    get inputs(): InputHandler;
-    get vims(): IReadonlyVimCollection;
-    /**
-     * The viewport API for managing the rendering viewport.
-     */
-    get viewport(): IViewport;
-    get renderer(): IRenderer;
-    get decoder(): IDecoder;
-    get raycaster(): IUltraRaycaster;
-    get selection(): ISelection;
-    /**
-     * API to create, manage, and destroy colors.
-     */
-    readonly colors: ColorManager;
-    /**
-     * Gets the current URL to which the viewer is connected.
-     * @returns The URL as a string, or undefined if not connected.
-     */
-    get serverUrl(): string | undefined;
-    /**
-     * Event that is triggered when the viewer's connection status changes.
-     * @returns An event that emits the current ClientStatus.
-     */
-    get onStateChanged(): ISimpleEvent<ClientState>;
-    /**
-     * Gets the current connection status of the viewer.
-     * @returns The current ClientStatus.
-     */
-    get connectionState(): ClientState;
-    /**
-     * The section box API for controlling the section box.
-     */
-    readonly sectionBox: SectionBox;
-    /**
-     * Creates a Viewer instance with a new canvas element appended to the given parent element.
-     * @param parent - The parent HTML element to which the canvas will be appended.
-     * @param logger - Optional logger for logging messages.
-     * @returns A new instance of the Viewer class.
-     */
-    static createWithCanvas(parent: HTMLElement, logger?: ILogger): Viewer;
-    /**
-     * Constructs a new Viewer instance.
-     * @param canvas - The HTML canvas element for rendering.
-     * @param logger - Optional logger for logging messages.
-     */
-    constructor(canvas: HTMLCanvasElement, logger?: ILogger);
-    /**
-     * Handles connection logic when the viewer connects to the server.
-     * Initializes components and checks for API version compatibility.
-     */
-    private onConnect;
-    private validateConnection;
-    private checkAPIVersion;
-    /**
-     * Handles disconnection logic when the viewer disconnects from the server.
-     * Cleans up resources and stops tracking.
-     */
-    private onDisconnect;
-    /**
-     * Connects to a VIM Ultra server.
-     * @param url - The server URL to connect to. Defaults to 'ws://localhost:8123'.
-     * @returns A promise that resolves when the connection is established.
-     */
-    connect(settings?: ConnectionSettings): Promise<boolean>;
-    /**
-     * Disconnects from the current VIM Ultra server.
-     */
-    disconnect(): void;
-    /**
-     * Requests the server to load the given URL or file path.
-     * @param source - The path or URL to the VIM file.
-     * @returns A load request object that can be used to wait for the load to complete.
-     */
-    loadVim(source: VimSource): ILoadRequest;
-    /**
-     * Unloads the given VIM from the viewer.
-     * @param vim - The VIM instance to unload.
-     */
-    unloadVim(vim: Vim): void;
-    /**
-     * Clears all loaded VIMs from the viewer.
-     */
-    clearVims(): void;
-    getElement3Ds(): Promise<number>;
-    /**
-     * Disposes all resources used by the viewer and disconnects from the server.
-     */
-    dispose(): void;
-}

package/dist/types/core-viewers/ultra/viewport.d.ts

@@ -1,47 +0,0 @@
-import { ILogger } from "./logger";
-import { RpcSafeClient } from "./rpcSafeClient";
-/**
- * Interface defining viewport functionality
- */
-export interface IViewport {
-    /** The HTML canvas element used for rendering */
-    canvas: HTMLCanvasElement;
-    /** Updates the aspect ratio of the viewport on the server */
-    update(): void;
-    /** Resizes the viewport to match its parent's dimensions */
-    resizeToParent(): void;
-}
-/**
- * Class managing the viewport and canvas resizing functionality
- */
-export declare class Viewport {
-    /** The HTML canvas element used for rendering */
-    canvas: HTMLCanvasElement;
-    private _rpc;
-    private _logger;
-    private _observer;
-    private _clearTimeout;
-    /**
-     * Creates a new Viewport instance
-     * @param canvas - The HTML canvas element to observe and manage
-     * @param rpc - RPC client for viewport communication
-     */
-    constructor(canvas: HTMLCanvasElement, rpc: RpcSafeClient, logger: ILogger);
-    /**
-     * Handles resize events for the canvas
-     * @private
-     */
-    private onResize;
-    /**
-     * Updates the aspect ratio of the viewport on the server
-     */
-    update(): void;
-    /**
-     * Resizes the viewport to match its parent's dimensions
-     */
-    resizeToParent(): void;
-    /**
-     * Cleans up resources by removing resize observer and clearing timeouts
-     */
-    dispose(): void;
-}

package/dist/types/core-viewers/ultra/vim.d.ts

@@ -1,50 +0,0 @@
-import type { IVim } from '../shared/vim';
-import type { ILogger } from './logger';
-import { ColorManager } from './colorManager';
-import { Element3D } from './element3d';
-import { LoadRequest } from './loadRequest';
-import { VisibilitySynchronizer } from './visibility';
-import { Renderer } from './renderer';
-import { RpcSafeClient, VimSource } from './rpcSafeClient';
-import * as THREE from 'three';
-export declare class Vim implements IVim<Element3D> {
-    readonly type = "ultra";
-    readonly source: VimSource;
-    private _handle;
-    private _request;
-    private readonly _rpc;
-    private _colors;
-    private _renderer;
-    private _logger;
-    readonly visibility: VisibilitySynchronizer;
-    private _elementColors;
-    private _updatedColors;
-    private _removedColors;
-    private _updateScheduled;
-    private _elementCount;
-    private _objects;
-    constructor(rpc: RpcSafeClient, color: ColorManager, renderer: Renderer, source: VimSource, logger: ILogger);
-    getElement(elementIndex: number): Element3D;
-    getElementsFromId(id: number): Element3D[];
-    getElementFromIndex(element: number): Element3D;
-    getObjectsInBox(box: THREE.Box3): Element3D[];
-    getAllElements(): Element3D[];
-    get handle(): number;
-    get connected(): boolean;
-    connect(): LoadRequest;
-    disconnect(): void;
-    private _load;
-    private getErrorType;
-    private _getHandle;
-    getBoundingBoxForElements(elements: number[] | 'all'): Promise<THREE.Box3 | undefined>;
-    getBoundingBox(): Promise<THREE.Box3 | undefined>;
-    getColor(elementIndex: number): THREE.Color | undefined;
-    setColor(elementIndex: number[], color: THREE.Color | undefined): Promise<void>;
-    setColors(elements: number[], color: (THREE.Color | undefined)[]): Promise<void>;
-    private applyColor;
-    clearColor(elements: number[] | 'all'): void;
-    reapplyColors(): void;
-    private scheduleColorUpdate;
-    private updateRemote;
-    private updateRemoteColors;
-}

package/dist/types/core-viewers/ultra/vimCollection.d.ts

@@ -1,51 +0,0 @@
-import { ISignal } from 'ste-signals';
-import { IReadonlyVimCollection as ISharedReadonlyVimCollection, IVimCollection } from '../shared/vimCollection';
-import { Vim } from './vim';
-export interface IReadonlyVimCollection extends ISharedReadonlyVimCollection<Vim> {
-    /** Get vim at a specific index */
-    getAt(index: number): Vim | undefined;
-}
-export declare class VimCollection implements IVimCollection<Vim>, IReadonlyVimCollection {
-    private _vims;
-    private _onChanged;
-    get onChanged(): ISignal;
-    constructor();
-    get count(): number;
-    /**
-     * Adds a Vim instance to the collection.
-     * @param vim - The Vim instance to add.
-     */
-    add(vim: Vim): void;
-    /**
-     * Removes a Vim instance from the collection.
-     * @param vim - The Vim instance to remove.
-     */
-    remove(vim: Vim): void;
-    /**
-     * Gets a Vim instance by its stable ID.
-     * @param id - The ID of the Vim instance.
-     * @returns The Vim instance or undefined if not found.
-     */
-    getFromId(id: number): Vim | undefined;
-    /**
-     * Checks if a vim is in the collection.
-     * @param vim - The Vim instance to check.
-     * @returns True if the vim is in the collection.
-     */
-    has(vim: Vim): boolean;
-    /**
-     * Gets a Vim instance at a specific index.
-     * @param index - The index of the Vim instance.
-     * @returns The Vim instance or undefined if the index is out of bounds.
-     */
-    getAt(index: number): Vim | undefined;
-    /**
-     * Gets all Vim instances.
-     * @returns An array of Vim instances.
-     */
-    getAll(): ReadonlyArray<Vim>;
-    /**
-     * Clears all Vim instances from the collection.
-     */
-    clear(): void;
-}

package/dist/types/core-viewers/ultra/visibility.d.ts

@@ -1,100 +0,0 @@
-import { RpcSafeClient } from './rpcSafeClient';
-/**
- * Represents the possible states an element can have in the UltraVim system.
- */
-export declare enum VisibilityState {
-    VISIBLE = 0,
-    HIDDEN = 1,
-    GHOSTED = 2,
-    HIGHLIGHTED = 16,
-    HIDDEN_HIGHLIGHTED = 17,
-    GHOSTED_HIGHLIGHTED = 18
-}
-/**
- * A class that wraps a StateTracker and is responsible for synchronizing its state updates with the remote RPCs.
- * It batches updates to optimize performance and handles the communication with the remote system.
- */
-export declare class VisibilitySynchronizer {
-    private _tracker;
-    private _rpc;
-    private _getHandle;
-    private _onUpdate;
-    private _isConnected;
-    private _animationFrame;
-    /**
-     * Creates a new StateSynchronizer instance.
-     *
-     * @param rpc - The RPC client used to communicate with the remote system
-     * @param getHandle - Function that returns the current handle identifier
-     * @param isConnected - Function that returns whether the connection to the remote system is active
-     * @param onUpdate - Callback function invoked when updates are sent to the remote system
-     * @param defaultState - The default state for elements when not explicitly set (defaults to VISIBLE)
-     */
-    constructor(rpc: RpcSafeClient, getHandle: () => number, isConnected: () => boolean, onUpdate: () => void, defaultState?: VisibilityState);
-    /**
-     * Checks if all elements are in the specified state(s).
-     *
-     * @param state - A single state or array of states to check against
-     * @returns True if all elements are in the specified state(s), false otherwise
-     */
-    areAllInState(state: VisibilityState | VisibilityState[]): boolean;
-    /**
-     * Gets the current state of a specific element.
-     *
-     * @param elementIndex - The element index
-     * @returns The current state of the element
-     */
-    getElementState(elementIndex: number): VisibilityState;
-    /**
-     * Gets all elements that are currently in the specified state.
-     *
-     * @param state - The state to query
-     * @returns Either 'all' if all elements are in this state, or an array of element indices
-     */
-    getElementsInState(state: VisibilityState): number[] | 'all';
-    /**
-     * Gets the default state used for elements without explicit state settings.
-     *
-     * @returns The current default state
-     */
-    getDefaultState(): VisibilityState;
-    /**
-     * Sets the state of a specific elements.
-     *
-     * @param elementIndex - The element index to update
-     * @param state - The new state to apply
-     */
-    setStateForElement(elementIndex: number, state: VisibilityState): void;
-    /**
-     * Sets the state of all elements to the specified value.
-     *
-     * @param state - The state to apply to all elements
-     * @param clear - If true, clears all elements-specific overrides
-     */
-    setStateForAll(state: VisibilityState): void;
-    /**
-     * Replaces all elements in one state (or states) with another state.
-     *
-     * @param fromState - The state(s) to replace
-     * @param toState - The new state to apply
-     */
-    replaceState(fromState: VisibilityState | VisibilityState[], toState: VisibilityState): void;
-    /**
-     * Reapplies all current state settings, useful after a reconnection.
-     * This will remove redundant overrides and ensure consistency.
-     */
-    reapplyStates(): void;
-    /**
-     * Schedules a synchronization on the next animation frame.
-     * This batches multiple rapid state changes to avoid excessive RPC calls.
-     *
-     * @private
-     */
-    private scheduleUpdate;
-    /**
-     * Processes all pending updates and sends them to the remote system.
-     *
-     * @private
-     */
-    private remoteUpdate;
-}

package/dist/types/core-viewers/webgl/index.d.ts

@@ -1,5 +0,0 @@
-import './style.css';
-import { BFastSource } from 'vim-format';
-export type VimSource = BFastSource;
-export * from './loader';
-export * from './viewer';

package/dist/types/core-viewers/webgl/loader/averageBoundingBox.d.ts

@@ -1,6 +0,0 @@
-import * as THREE from 'three';
-/**
- * Returns the bounding box of the average center of all meshes.
- * Less precise but is more stable against outliers.
- */
-export declare function getAverageBoundingBox(positions: THREE.Vector3[], thresholdSpan?: number, framingDistanceMultiplier?: number): THREE.Box3;

package/dist/types/core-viewers/webgl/loader/colorAttribute.d.ts

@@ -1,34 +0,0 @@
-/**
- * @module vim-loader
- */
-import * as THREE from 'three';
-import { Vim } from './vim';
-import { WebglAttributeTarget } from './webglAttribute';
-export declare class WebglColorAttribute {
-    readonly vim: Vim;
-    private _meshes;
-    private _value;
-    constructor(meshes: WebglAttributeTarget[] | undefined, value: THREE.Color | undefined, vim: Vim | undefined);
-    updateMeshes(meshes: WebglAttributeTarget[] | undefined): void;
-    get value(): THREE.Color;
-    apply(color: THREE.Color | undefined): void;
-    /**
-     * Writes new color to the appropriate section of merged mesh color buffer.
-     * @param index index of the merged mesh instance
-     * @param color rgb representation of the color to apply
-     */
-    private applyMergedColor;
-    /**
-     * Repopulates the color buffer of the merged mesh from original g3d data.
-     * @param index index of the merged mesh instance
-     */
-    private resetMergedColor;
-    private resetMergedInsertableColor;
-    /**
-     * Adds an instanceColor buffer to the instanced mesh and sets new color for given instance
-     * @param index index of the instanced instance
-     * @param color rgb representation of the color to apply
-     */
-    private applyInstancedColor;
-    private getOrAddInstanceColorAttribute;
-}