vim-web 0.6.0-dev.0 → 0.6.0-dev.10

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

@@ -1,116 +0,0 @@
-import { RpcSafeClient } from './rpcSafeClient';
-import { Element3D } from './element3d';
-import { Vim } from './vim';
-import { Segment } from './rpcTypes';
-import * as THREE from 'three';
-/**
- * Interface defining camera control operations in the 3D viewer
- * @interface
- */
-export interface ICamera {
-    /**
-     * Frames all Vim models in the viewer to fit within the camera view
-     * @param {number} [blendTime=0.5] - Animation duration in seconds
-     * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
-     */
-    frameAll(blendTime?: number): Promise<Segment | undefined>;
-    /**
-     * Frames a specified bounding box in the viewer
-     * @param {Box3} box - The 3D bounding box to frame
-     * @param {number} [blendTime=0.5] - Animation duration in seconds
-     * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
-     */
-    frameBox(box: THREE.Box3, blendTime?: number): Promise<Segment | undefined>;
-    /**
-     * Frames specified nodes of a Vim model in the camera view
-     * @param {Vim} vim - The target Vim model
-     * @param {number[] | 'all'} nodes - Array of node indices or 'all' for entire model
-     * @param {number} [blendTime=0.5] - Animation duration in seconds
-     * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
-     */
-    frameVim(vim: Vim, nodes: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
-    /**
-     * Frames a specific object in the camera view
-     * @param {Element3D} object - The target object to frame
-     * @param {number} [blendTime=0.5] - Animation duration in seconds
-     * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
-     */
-    frameObject(object: Element3D, blendTime?: number): Promise<Segment | undefined>;
-    /**
-     * Saves the current camera position for later restoration
-     * @param {Segment} [segment] - Optional specific camera position to save
-     */
-    save(segment?: Segment): void;
-    /**
-     * Controls the rendering state of the viewer
-     * @param {boolean} value - True to pause, false to resume rendering
-     */
-    pause(value: boolean): void;
-    /**
-     * Restores the camera to its previously saved position
-     * Initially that will be the first call to a Frame method
-     * @param {number} [blendTime=0.5] - Animation duration in seconds
-     */
-    restoreSavedPosition(blendTime?: number): void;
-}
-/**
- * Implements camera control operations for the 3D viewer
- * @class
- */
-export declare class Camera implements ICamera {
-    private _rpc;
-    private _lastPosition;
-    private _defaultBlendTime;
-    private _savedPosition;
-    /**
-     * Creates a new Camera instance
-     * @param rpc - RPC client for camera communication
-     */
-    constructor(rpc: RpcSafeClient);
-    /**
-     * Saves the current camera position for later restoration
-     * @param segment - Optional segment to save as the camera position
-     */
-    save(segment?: Segment): Promise<void>;
-    /**
-     * Resets the camera to the last saved position
-     */
-    restoreSavedPosition(blendTime?: number): void;
-    /**
-     * Restores the camera to its last tracked position
-     * @param blendTime - Duration of the camera animation in seconds
-     */
-    restoreLastPosition(blendTime?: number): void;
-    /**
-     * Handles camera initialization when connection is established
-     */
-    onConnect(): void;
-    onCameraPose(pose: Segment): void;
-    set(position: THREE.Vector3, target: THREE.Vector3, blendTime?: number): void;
-    /**
-     * Pauses or resumes rendering
-     * @param value - True to pause rendering, false to resume
-     */
-    pause(value: boolean): void;
-    /**
-     * Frames all vims in the viewer to fit within the camera view
-     * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
-     * @returns Promise that resolves when the framing animation is complete
-     */
-    frameAll(blendTime?: number): Promise<Segment | undefined>;
-    /**
-     * Frames a specific bounding box in the viewer
-     * @param box - The 3D bounding box to frame in the camera view
-     * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
-     */
-    frameBox(box: THREE.Box3, blendTime?: number): Promise<Segment | undefined>;
-    /**
-     * Frames specific nodes of a Vim model in the camera view
-     * @param vim - The Vim model containing the nodes to frame
-     * @param elements - Array of element indices to frame, or 'all' to frame the entire model
-     * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
-     * @returns Promise that resolves when the framing animation is complete
-     */
-    frameVim(vim: Vim, elements: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
-    frameObject(object: Element3D, blendTime?: number): Promise<Segment | undefined>;
-}

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

@@ -1,73 +0,0 @@
-import { RpcSafeClient } from './rpcSafeClient';
-import { RemoteColor } from './remoteColor';
-import * as THREE from 'three';
-/**
- * Manages the creation, caching, and deletion of color instances.
- * Handles batched deletion of colors to optimize RPC calls.
- */
-export declare class ColorManager {
-    private _rpc;
-    private _hexToColor;
-    private _idToColor;
-    private _toDelete;
-    private _deleteId;
-    /**
-     * Creates a new ColorManager instance.
-     * @param rpc - The RPC client used for communication with the rendering backend
-     */
-    constructor(rpc: RpcSafeClient);
-    /**
-     * Creates or retrieves a cached color instance for the given hex value.
-     * @param hex - The RGBA32 color value
-     * @returns Promise resolving to a ColorHandle, or undefined if creation fails
-     */
-    getColor(color: THREE.Color): Promise<RemoteColor | undefined>;
-    /**
-     * Creates or retrieves cached color instances for multiple hex values.
-     * @param colors - Array of color values or undefined for no color
-     * @returns Promise resolving to an array of ColorHandles in the same order as input, or undefined if creation fails
-     * @remarks Duplicate hex values will be mapped to the same color instance for efficiency
-     */
-    getColors(colors: (THREE.Color | undefined)[]): Promise<RemoteColor[]>;
-    /**
-     * Retrieves a color instance by its unique identifier.
-     * @param id - The unique identifier of the color
-     * @returns The ColorHandle associated with the ID, or undefined if not found
-     */
-    getFromId(id: number): RemoteColor;
-    /**
-     * Destroys a color instance and removes it from the cache.
-     * @param color - The ColorHandle to destroy
-     */
-    destroy(color: RemoteColor): void;
-    /**
-     * Destroys all color instances and clears the cache.
-     */
-    clear(): void;
-    /**
-     * Creates multiple color instances via RPC.
-     * @param colors - Array of RGBA32 color values to create
-     * @returns Promise resolving to an array of ColorHandles, or undefined if creation fails
-     * @private
-     */
-    private _createColors;
-    /**
-     * Creates a single color instance and adds it to the cache.
-     * @param color - The RGBA32 color value
-     * @param id - The unique identifier for the color instance
-     * @returns The created ColorHandle
-     * @private
-     */
-    private _createColor;
-    /**
-     * Queues a color for deletion in the next batch.
-     * @param color - The ColorHandle to delete
-     * @private
-     */
-    private _deleteColor;
-    /**
-     * Immediately deletes all queued colors.
-     * @private
-     */
-    private _deleteBatch;
-}

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

@@ -1,108 +0,0 @@
-import type { VideoFrameMessage } from './protocol';
-import { ILogger } from './logger';
-/**
- * Interface defining the basic decoder operations
- */
-export interface IDecoder {
-    /** Indicates if the decoder is ready to process frames */
-    ready: boolean;
-    /** Indicates if the decoder is currently paused */
-    paused: boolean;
-    /** Stops the decoder operations */
-    stop(): void;
-    /** Starts the decoder operations */
-    start(): void;
-}
-/**
- * Decoder class responsible for decoding video frames and rendering them using WebGL.
- * Handles frame queueing, decoding, and rendering through WebGL.
- */
-export declare class Decoder implements IDecoder {
-    private _decoder;
-    private readonly _canvas;
-    private readonly _renderer;
-    private readonly _logger;
-    private _firstDecoded;
-    private _skipUntil;
-    private _queue;
-    private _pendingFrame;
-    private _renderId;
-    private _decodeId;
-    /**
-     * Indicates whether the decoder is ready and configured.
-     * @returns {boolean} True if the decoder is configured, false otherwise.
-     */
-    get ready(): boolean;
-    /**
-     * Creates an instance of the Decoder class.
-     * @param originalCanvas - The original HTML canvas element to render frames onto
-     * @param logger - Logger instance for debugging and error reporting
-     * @throws {Error} When video decoder configuration is not supported
-     */
-    constructor(originalCanvas: HTMLCanvasElement, logger: ILogger);
-    /**
-     * Indicates whether the decoder is currently paused.
-     * @returns {boolean} True if paused, false otherwise.
-     */
-    get paused(): boolean;
-    /**
-     * Pauses the decoder and renderer.
-     */
-    stop(): void;
-    /**
-     * Resumes the decoder and renderer.
-     */
-    start(): void;
-    /**
-     * Clears decoding and rendering callbacks.
-     */
-    private _clearCallbacks;
-    /**
-     * Enqueues a video frame message for decoding.
-     * If a key frame is received, the queue is cleared except for the first frame
-     * to maintain decoder stability.
-     * @param frame - The video frame message to be queued for decoding
-     */
-    enqueue(frame: VideoFrameMessage): void;
-    /**
-     * Processes and decodes all queued video frame messages.
-     * Skips processing if the decoder isn't ready or the queue is empty.
-     * @throws {Error} When decoding fails for a video chunk
-     */
-    decode(): void;
-    /**
-     * Clears the decoder state and renderer buffer.
-     * Does not close the decoder instance.
-     */
-    clear(): void;
-    /**
-     * Completely disposes of the decoder instance and releases all resources.
-     * Should be called when the decoder is no longer needed.
-     */
-    dispose(): void;
-    /**
-     * Cleans up internal resources and cancels ongoing operations.
-     * @private
-     */
-    private _cleanUp;
-    /**
-     * Creates an EncodedVideoChunk from a VideoFrameMessage.
-     * @param message - The video frame message to convert
-     * @returns {EncodedVideoChunk} A chunk ready for decoder processing
-     * @private
-     */
-    private createChunk;
-    /**
-     * Handles the animation loop for continuous frame rendering.
-     * Processes pending frames and manages the render timing.
-     * @private
-     */
-    private animate;
-    /**
-     * Processes a decoded video frame for rendering.
-     * Manages frame replacement and cleanup of previous frames.
-     * @param frame - The decoded video frame ready for rendering
-     * @private
-     */
-    private renderFrame;
-}

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

@@ -1,80 +0,0 @@
-import type { VideoFrameMessage } from './protocol';
-import { ILogger } from './logger';
-export declare enum FrameType {
-    KeyFrame = 0,
-    DeltaFrame = 1
-}
-/**
- * Decoder class responsible for decoding video frames and rendering them using WebGL.
- */
-export declare class DecoderWithWorker {
-    private readonly _canvas;
-    private readonly _renderer;
-    private readonly _logger;
-    private _firstDecoded;
-    private _skipUntil;
-    private _queue;
-    private _pendingFrame;
-    private _renderId;
-    private _decodeId;
-    private _worker;
-    /**
-     * Indicates whether the decoder is ready and configured.
-     * @returns {boolean} True if the decoder is configured, false otherwise.
-     */
-    get ready(): boolean;
-    /**
-     * Creates an instance of the Decoder class.
-     * @param originalCanvas - The original HTML canvas element.
-     * @param logger - Logger for logging messages and errors.
-     */
-    constructor(originalCanvas: HTMLCanvasElement, logger: ILogger);
-    sendFrameToWorker(frame: VideoFrameMessage): void;
-    /**
-     * Indicates whether the decoder is currently paused.
-     * @returns {boolean} True if paused, false otherwise.
-     */
-    get paused(): boolean;
-    /**
-     * Pauses the decoder and renderer.
-     */
-    stop(): void;
-    /**
-     * Resumes the decoder and renderer.
-     */
-    start(): void;
-    /**
-     * Clears decoding and rendering callbacks.
-     */
-    private _clearCallbacks;
-    /**
-     * Enqueues a video frame message for decoding.
-     * @param frame - The video frame message to enqueue.
-     */
-    enqueue(frame: VideoFrameMessage): void;
-    /**
-     * Decodes enqueued video frame messages.
-     */
-    decode(): void;
-    /**
-     * Clears the decoder and renderer, resetting the internal state.
-     */
-    clear(): void;
-    /**
-     * Disposes of the decoder, releasing resources.
-     */
-    dispose(): void;
-    /**
-     * Cleans up the renderer and clears the frame queue.
-     */
-    private _cleanUp;
-    /**
-     * Animation loop for rendering frames.
-     */
-    private animate;
-    /**
-     * Handles rendering of a decoded video frame.
-     * @param frame - The decoded video frame.
-     */
-    private renderFrame;
-}

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

@@ -1,44 +0,0 @@
-import { IVimElement } from "../shared/vim";
-import { VisibilityState } from "./visibility";
-import { Vim } from "./vim";
-import * as THREE from "three";
-/**
- * Represents a single 3D element within a `Vim` model.
- * Provides access to per-instance state, color, and bounding box.
- */
-export declare class Element3D implements IVimElement {
-    /**
-     * The parent `Vim` instance this element belongs to.
-     */
-    readonly vim: Vim;
-    /**
-     * The internal instance index within the `Vim` model.
-     */
-    readonly element: number;
-    /**
-     * The unique handle of the parent `Vim` model.
-     */
-    get vimHandle(): number;
-    /**
-     * Creates a new `Element3D` instance.
-     * @param vim - The parent `Vim` model.
-     * @param element - The internal instance index.
-     */
-    constructor(vim: Vim, element: number);
-    /**
-     * Gets or sets the display state of the element (e.g., visible, hidden).
-     */
-    get state(): VisibilityState;
-    set state(state: VisibilityState);
-    /**
-     * Gets or sets the color override of the element.
-     */
-    get color(): THREE.Color | undefined;
-    set color(color: THREE.Color | undefined);
-    /**
-     * Computes and returns the bounding box of the element.
-     * Returns undefined if the element is abstract.
-     * @returns A promise resolving to the element's bounding box.
-     */
-    getBoundingBox(): Promise<THREE.Box3 | undefined>;
-}

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

@@ -1,29 +0,0 @@
-import "./style.css";
-export * from './viewer';
-export { Segment, type SectionBoxState, type HitCheckResult, type VimStatus } from './rpcTypes';
-export { materialHandles, MaterialHandles, type MaterialHandle, } from './rpcClient';
-export { InputMode, VimLoadingStatus } from './rpcSafeClient';
-export { VisibilityState } from './visibility';
-export type * from './camera';
-export type * from './colorManager';
-export type * from './decoder';
-export type * from './visibility';
-export type * from './element3d';
-export type * from './inputAdapter';
-export type * from './loadRequest';
-export type * from './logger';
-export type * from './protocol';
-export type * from './raycaster';
-export type * from './remoteColor';
-export type * from './renderer';
-export type * from './rpcClient';
-export type * from './rpcMarshal';
-export type * from './rpcSafeClient';
-export type * from './sectionBox';
-export type * from './selection';
-export type * from './socketClient';
-export type * from './streamLogger';
-export type * from './streamRenderer';
-export type * from './viewport';
-export type * from './vim';
-export type * from './vimCollection';

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

@@ -1,8 +0,0 @@
-import { InputHandler } from "../shared/inputHandler";
-import { Viewer } from "./viewer";
-/**
- * Creates a new `InputHandler` connected to the provided `Viewer`.
- * @param viewer - The target viewer.
- * @returns An `InputHandler` instance wired to the viewer.
- */
-export declare function ultraInputAdapter(viewer: Viewer): InputHandler;

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

@@ -1,14 +0,0 @@
-import { Vim } from './vim';
-import { LoadRequest as BaseLoadRequest, ILoadRequest as BaseILoadRequest, IProgress, LoadError as SharedLoadError } from '../shared/loadResult';
-export type VimRequestErrorType = 'loadingError' | 'downloadingError' | 'serverDisconnected' | 'unknown' | 'cancelled';
-export declare class LoadError extends SharedLoadError {
-    readonly type: VimRequestErrorType;
-    constructor(error: VimRequestErrorType, details?: string);
-}
-export type ILoadRequest = BaseILoadRequest<Vim, LoadError>;
-export declare class LoadRequest extends BaseLoadRequest<Vim, LoadError> {
-    onProgress(progress: IProgress): void;
-    success(vim: Vim): this;
-    error(error: VimRequestErrorType, details?: string): this;
-    abort(): void;
-}

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

@@ -1,9 +0,0 @@
-export interface ILogger {
-    log(message: string, obj?: any): void;
-    error: (message: string, e: unknown) => void;
-}
-export declare const defaultLogger: ILogger;
-export declare function createLogger(onMsg: (str: string) => void): {
-    log: (str: string) => void;
-    error: (str: string, e: unknown) => void;
-};

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

@@ -1,13 +0,0 @@
-export interface VideoFrameHeader {
-    timestamp: number;
-    duration: number;
-    frameType: number;
-    dataLength: number;
-}
-export interface VideoFrameMessage {
-    header: VideoFrameHeader;
-    dataBuffer: ArrayBuffer;
-}
-export declare const HEADER_SIZE = 16;
-export declare function readHeader(buffer: ArrayBuffer): VideoFrameHeader;
-export declare function readBlob(blob: Blob): Promise<VideoFrameMessage>;

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

@@ -1,52 +0,0 @@
-import * as THREE from "three";
-import type { IRaycastResult, IRaycaster } from "../shared/raycaster";
-import { Element3D } from "./element3d";
-import { RpcSafeClient } from "./rpcSafeClient";
-import { IReadonlyVimCollection } from "./vimCollection";
-export type IUltraRaycastResult = IRaycastResult<Element3D>;
-export type IUltraRaycaster = IRaycaster<Element3D>;
-/**
- * Represents the result of a hit test operation.
- */
-export declare class UltraRaycastResult implements IUltraRaycastResult {
-    /** The model Object hit */
-    object: Element3D;
-    /** The 3D world position of the hit point */
-    worldPosition: THREE.Vector3;
-    /** The surface normal at the hit point */
-    worldNormal: THREE.Vector3;
-    constructor(object: Element3D, worldPosition: THREE.Vector3, worldNormal: THREE.Vector3);
-}
-/**
- * @module ultra-webgl-viewer
- */
-/**
- * Handles raycasting operations in the Ultra system, enabling picking and
- * interaction with 3D objects in the scene.
- */
-export declare class Raycaster implements IUltraRaycaster {
-    private _rpc;
-    private _vims;
-    /**
-     * Creates a new UltraCoreRaycaster instance.
-     *
-     * @param {RpcSafeClient} rpc - RPC client for communication with the viewer.
-     * @param {IReadonlyVimCollection} vims - Collection of VIM instances to manage.
-     */
-    constructor(rpc: RpcSafeClient, vims: IReadonlyVimCollection);
-    /**
-     * Performs a raycast from the camera using normalized screen coordinates.
-     * Coordinates must be within [0, 1] for both x and y.
-     *
-     * @param {Vector2} position - The normalized screen position for raycasting.
-     * @returns {Promise<UltraRaycastResult | undefined>} Promise resolving to hit test result or undefined if no hit.
-     */
-    raycastFromScreen(position: THREE.Vector2): Promise<UltraRaycastResult>;
-    /**
-     * Performs a raycast from a specific world position towards a target.
-     *
-     * @param {Vector3} position - The target world position for raycasting.
-     * @returns {Promise<UltraRaycastResult | undefined>} Promise resolving to hit test result or undefined if no hit.
-     */
-    raycastFromWorld(position: THREE.Vector3): Promise<UltraRaycastResult | undefined>;
-}

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

@@ -1,37 +0,0 @@
-import { ColorManager } from './colorManager';
-import * as THREE from 'three';
-/**
- * Represents a handle to a color in the color management system.
- * This class provides access to color components and manages the lifecycle of color instances.
- */
-export declare class RemoteColor {
-    private _manager;
-    /** Unique identifier for the color instance */
-    readonly id: number;
-    /** The RGBA color value */
-    readonly color: THREE.Color;
-    private _disposed;
-    /**
-     * Indicates whether the color handle has been disposed.
-     * @returns {boolean} True if the color handle has been disposed, false otherwise.
-     */
-    get disposed(): boolean;
-    /**
-     * Gets the hexadecimal representation of the color.
-     * @returns {number} The color value as a hexadecimal number.
-     */
-    get hex(): number;
-    /**
-     * Creates a new ColorHandle instance.
-     * @param {RGBA32} color - The RGBA color value.
-     * @param {number} serverId - The unique identifier assigned by the server.
-     * @param {ColorManager} manager - The color manager instance that manages this color handle.
-     */
-    constructor(color: THREE.Color, serverId: number, manager: ColorManager);
-    /**
-     * Disposes of the color handle and releases associated resources.
-     * Once disposed, the color handle cannot be used anymore.
-     * Multiple calls to dispose are safely ignored.
-     */
-    dispose(): void;
-}