vim-web 0.3.44-dev.9 → 0.4.0

package/dist/types/core-viewers/ultra/{viewer/rpcSafeClient.d.ts → rpcSafeClient.d.ts}

@@ -1,5 +1,4 @@
-import { Box3, RGBA, RGBA32, Segment, Vector2, Vector3 } from "../utils/math3d";
-import { HitCheckResult, SectionBoxState } from "./marshal";
+import * as RpcTypes from "./rpcTypes";
 import { MaterialHandle, RpcClient } from "./rpcClient";
 export type VimSource = {
     url: string;
@@ -19,7 +18,7 @@ export type SceneSettings = {
     hdrBackgroundScale: number;
     hdrBackgroundSaturation: number;
     backGroundBlur: number;
-    backgroundColor: RGBA;
+    backgroundColor: RpcTypes.RGBA;
 };
 export declare const defaultSceneSettings: SceneSettings;
 export declare enum VimLoadingStatus {
@@ -57,7 +56,7 @@ export declare class RpcSafeClient {
      */
     RPCSetLighting(settings: SceneSettings): void;
     RPCLockIblRotation(lock: boolean): void;
-    RPCGetSceneAABB(): Promise<Box3 | undefined>;
+    RPCGetSceneAABB(): Promise<RpcTypes.Box3 | undefined>;
     /*******************************************************************************
      * NODE VISIBILITY METHODS
      * Methods for controlling node visibility, including show/hide, ghosting,
@@ -131,7 +130,7 @@ export declare class RpcSafeClient {
      * @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>;
+    RPCCreateText(position: RpcTypes.Vector3, color: RpcTypes.RGBA32, text: string): Promise<number>;
     /**
      * Destroys a text component, removing it from the scene.
      * @param componentHandle - The handle of the text component to destroy
@@ -143,8 +142,8 @@ export declare class RpcSafeClient {
      * Methods for controlling section box visibility and position.
      ******************************************************************************/
     RPCEnableSectionBox(enable: boolean): void;
-    RPCSetSectionBox(state: SectionBoxState): void;
-    RPCGetSectionBox(): Promise<SectionBoxState | undefined>;
+    RPCSetSectionBox(state: RpcTypes.SectionBoxState): void;
+    RPCGetSectionBox(): Promise<RpcTypes.SectionBoxState | undefined>;
     /*******************************************************************************
      * CAMERA AND VIEW METHODS
      * Methods for controlling camera position, movement, framing, and view settings.
@@ -153,15 +152,15 @@ export declare class RpcSafeClient {
      * 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>;
+    RPCGetCameraPosition(): Promise<RpcTypes.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;
-    RPCGetBoundingBoxAll(componentHandle: number): Promise<any>;
+    RPCSetCameraPosition(segment: RpcTypes.Segment, blendTime: number): void;
+    RPCGetBoundingBoxAll(componentHandle: number): Promise<RpcTypes.Box3 | undefined>;
     /**
      * Calculates the bounding box for specified nodes in a component.
      * Large node arrays are automatically processed in batches for better performance.
@@ -170,14 +169,14 @@ export declare class RpcSafeClient {
      * @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>;
+    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<RpcTypes.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>;
+    RPCFrameAll(blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /**
      * Frames a specific VIM component in the scene.
      * @param componentHandle - The handle of the VIM component to frame
@@ -185,7 +184,7 @@ export declare class RpcSafeClient {
      * @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>;
+    RPCFrameVim(componentHandle: number, blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /**
      * Frames specific instances within a component. For large numbers of instances,
      * automatically switches to bounding box framing for better performance.
@@ -195,14 +194,14 @@ export declare class RpcSafeClient {
      * @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>;
+    RPCFrameInstances(componentHandle: number, nodes: number[], blendTime: number): Promise<RpcTypes.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>;
+    RPCFrameBox(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /*******************************************************************************
      * INPUT HANDLING METHODS
      * Methods for handling user input including mouse, keyboard, and camera controls.
@@ -260,13 +259,13 @@ export declare class RpcSafeClient {
      * Sets the color used for ghosted geometry.
      * @param ghostColor - The RGBA color to use for ghosted elements
      */
-    RPCSetGhostColor(ghostColor: RGBA): void;
+    RPCSetGhostColor(ghostColor: RpcTypes.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>;
+    RPCPerformHitTest(pos: RpcTypes.Vector2): Promise<RpcTypes.HitCheckResult | undefined>;
     /**
      * Sends a mouse button event to the viewer.
      * @param position - The normalized screen coordinates (0-1, 0-1)
@@ -274,19 +273,19 @@ export declare class RpcSafeClient {
      * @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;
+    RPCMouseButtonEvent(position: RpcTypes.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;
+    RPCMouseDoubleClickEvent(position: RpcTypes.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;
+    RPCMouseMoveEvent(position: RpcTypes.Vector2): void;
     /**
      * Sends a mouse scroll wheel event to the viewer.
      * @param scrollValue - The scroll amount (-1 to 1)
@@ -298,7 +297,7 @@ export declare class RpcSafeClient {
      * @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;
+    RPCMouseSelectEvent(position: RpcTypes.Vector2, mouseButton: number): void;
     /**
      * Sends a keyboard event to the viewer.
      * @param keyCode - The key code of the event
@@ -318,7 +317,7 @@ export declare class RpcSafeClient {
      * @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>;
+    RPCCreateMaterialInstances(materialHandle: MaterialHandle, smoothness: number, colors: RpcTypes.RGBA32[]): Promise<number[] | undefined>;
     private createMaterialInstancesBatched;
     /**
      * Destroys multiple material instances, freeing associated resources.
@@ -378,7 +377,7 @@ export declare class RpcSafeClient {
      * @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;
+    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RpcTypes.RGBA32[]): void;
     /**
      * Hides the axis-aligned bounding boxes (AABBs) for specified nodes.
      * Large node arrays are automatically processed in batches.

package/dist/types/core-viewers/ultra/{utils/math3d.d.ts → rpcTypes.d.ts}

@@ -1,18 +1,9 @@
-export { Matrix4 as Matrix44, } from 'three';
-export { Vector2, Vector3, Box3 } from 'three';
-import { Vector2, Vector3 } from 'three';
-/**
- * Checks if two Vector2 objects are approximately equal.
- * @param v1 - First Vector2.
- * @param v2 - Second Vector2.
- * @param epsilon - Tolerance for floating-point comparisons.
- * @returns True if vectors are almost equal, false otherwise.
- */
-export declare function almostEqual(v1: Vector2, v2: Vector2, epsilon?: number): boolean;
+import * as THREE from 'three';
+export { Vector2, Vector3, Box3, Matrix4 as Matrix44 } from 'three';
 export declare class Segment {
-    origin: Vector3;
-    target: Vector3;
-    constructor(origin?: Vector3, target?: Vector3);
+    origin: THREE.Vector3;
+    target: THREE.Vector3;
+    constructor(origin?: THREE.Vector3, target?: THREE.Vector3);
     static fromArray(array: number[]): Segment;
     toArray(): number[];
     isValid(): boolean;
@@ -24,6 +15,7 @@ export declare class RGBA {
     b: number;
     a: number;
     constructor(r: number, g: number, b: number, a?: number);
+    clone(): RGBA;
     isValid(): boolean;
     equals(color: RGBA): boolean;
     static fromString(str: string): RGBA;
@@ -57,11 +49,19 @@ export declare class RGBA32 {
      */
     get a(): number;
 }
-/**
- * Remaps the given value from the range [0-1] to [0-max].
- */
-export declare function remap(value: number, max: number): number;
-/**
- * Clamps the given value between the given min and max.
- */
-export declare function clamp(value: number, min: number, max: number): number;
+export type HitCheckResult = {
+    vimHandle: number;
+    nodeIndex: number;
+    worldPosition: THREE.Vector3;
+    worldNormal: THREE.Vector3;
+};
+export type VimStatus = {
+    status: number;
+    progress: number;
+};
+export type SectionBoxState = {
+    visible: boolean;
+    interactive: boolean;
+    clip: boolean;
+    box: THREE.Box3;
+};

package/dist/types/core-viewers/ultra/{viewer/sectionBox.d.ts → sectionBox.d.ts}

@@ -1,5 +1,5 @@
-import { Box3 } from "../utils/math3d";
 import { RpcSafeClient } from "./rpcSafeClient";
+import * as THREE from "three";
 export declare class SectionBox {
     private _visible;
     private _interactible;
@@ -8,6 +8,7 @@ export declare class SectionBox {
     private _rpc;
     private _interval;
     private _animationFrame;
+    private _pullId;
     private _onUpdate;
     get onUpdate(): import("ste-signals").ISignal;
     private get needUpdate();
@@ -22,7 +23,11 @@ export declare class SectionBox {
     set interactive(value: boolean);
     get clip(): boolean;
     set clip(value: boolean);
-    fitBox(box: Box3): void;
-    getBox(): Box3;
+    /**
+     * Fits the given box, invalid dimensions will be reversed.
+     * @param box - The new bounding box.
+     */
+    fitBox(box: THREE.Box3): void;
+    getBox(): THREE.Box3 | undefined;
     dispose(): void;
 }

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

@@ -0,0 +1,4 @@
+import { Selection } from "../shared/selection";
+import { Element3D } from "./element3d";
+export type ISelection = Selection<Element3D>;
+export declare function createSelection(): ISelection;

package/dist/types/core-viewers/ultra/{viewer/socketClient.d.ts → socketClient.d.ts}

@@ -1,8 +1,8 @@
-import * as Protocol from './protocol';
-import { Marshal, ReadMarshal } from './marshal';
 import { ILogger } from './logger';
-import { Segment } from '../utils/math3d';
-export declare const DEFAULT_LOCAL_ULTRA_SERVER_URL = "ws://localhost:8123";
+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;
@@ -41,13 +41,6 @@ export type ClientStreamError = {
     serverUrl: string;
     details: 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,

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

@@ -1,18 +1,19 @@
-import { IInputs } from './inputs/inputs';
-import { ClientState, ConnectionSettings } from './socketClient';
+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 { Vim } from './vim';
 import { ILoadRequest } from './loadRequest';
 import { ILogger } from './logger';
-import { IViewport } from './viewport';
-import { ColorManager } from './colorManager';
-import { ICamera } from './camera';
-import { RpcSafeClient, VimSource } from './rpcSafeClient';
-import { ISimpleEvent } from 'ste-simple-events';
-import { ViewerSelection } from './selection';
-import { IReadonlyVimCollection } from './vimCollection';
+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,
@@ -28,6 +29,7 @@ export declare class Viewer {
     private readonly _viewport;
     private readonly _camera;
     private readonly _selection;
+    private readonly _raycaster;
     private readonly _vims;
     private _disposed;
     /**
@@ -41,7 +43,7 @@ export declare class Viewer {
     /**
      * The input API for handling user input events.
      */
-    get inputs(): IInputs;
+    get inputs(): InputHandler;
     get vims(): IReadonlyVimCollection;
     /**
      * The viewport API for managing the rendering viewport.
@@ -49,7 +51,8 @@ export declare class Viewer {
     get viewport(): IViewport;
     get renderer(): IRenderer;
     get decoder(): IDecoder;
-    get selection(): ViewerSelection;
+    get raycaster(): IUltraRaycaster;
+    get selection(): ISelection;
     /**
      * API to create, manage, and destroy colors.
      */
@@ -68,7 +71,7 @@ export declare class Viewer {
      * Gets the current connection status of the viewer.
      * @returns The current ClientStatus.
      */
-    get state(): ClientState;
+    get connectionState(): ClientState;
     /**
      * The section box API for controlling the section box.
      */

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

@@ -0,0 +1,48 @@
+import type { IVim } from '../shared/vim';
+import type { ILogger } from './logger';
+import { ColorManager } from './colorManager';
+import { Element3D } from './element3d';
+import { LoadRequest } from './loadRequest';
+import { StateSynchronizer } from './nodeState';
+import { Renderer } from './renderer';
+import { RpcSafeClient, VimSource } from './rpcSafeClient';
+import * as THREE from 'three';
+import { RGBA32 } from './rpcTypes';
+export declare class Vim implements IVim<Element3D> {
+    readonly source: VimSource;
+    private _handle;
+    private _request;
+    private readonly _rpc;
+    private _colors;
+    private _renderer;
+    private _logger;
+    readonly nodeState: StateSynchronizer;
+    private _nodeColors;
+    private _updatedColors;
+    private _updateScheduled;
+    private _objects;
+    constructor(rpc: RpcSafeClient, color: ColorManager, renderer: Renderer, source: VimSource, logger: ILogger);
+    getElementFromInstanceIndex(instance: 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;
+    getBoundingBoxNodes(nodes: number[] | 'all'): Promise<THREE.Box3 | undefined>;
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
+    getColor(node: number): RGBA32 | undefined;
+    setColor(nodes: number[], color: RGBA32 | undefined): Promise<void>;
+    setColors(nodes: number[], color: (RGBA32 | undefined)[]): Promise<void>;
+    private applyColor;
+    clearColor(nodes: number[] | 'all'): void;
+    reapplyColors(): void;
+    private scheduleColorUpdate;
+    private updateRemote;
+    private updateRemoteColors;
+}

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

@@ -2,24 +2,5 @@ import './style.css';
 import { BFastSource } from 'vim-format';
 export type VimSource = BFastSource;
 export { IProgressLogs } from 'vim-format';
-export * from './loader/progressive/open';
-export * from './loader/progressive/vimRequest';
-export * from './loader/progressive/vimx';
-export * from './viewer/viewer';
-export * from './loader/geometry';
-export type { PointerMode, InputScheme } from './viewer/inputs/input';
-export { DefaultInputScheme, KEYS } from './viewer/inputs/input';
-export * from './viewer/settings/viewerSettings';
-export * from './viewer/settings/viewerSettingsParsing';
-export * from './viewer/settings/defaultViewerSettings';
-export { RaycastResult as HitTestResult, InputAction } from './viewer/raycaster';
-export { type SelectableObject } from './viewer/selection';
-export * from './loader/progressive/insertableMesh';
-export * from './loader/progressive/g3dSubset';
-export * from './loader/geometry';
-export * from './loader/materials/viewerMaterials';
-export * from './loader/object3D';
-export * from './loader/scene';
-export * from './loader/vim';
-export * from './loader/vimSettings';
-export * from './utils/boxes';
+export * from './loader';
+export * from './viewer';

package/dist/types/core-viewers/webgl/loader/{colorAttributes.d.ts → colorAttribute.d.ts}

@@ -3,13 +3,13 @@
  */
 import * as THREE from 'three';
 import { Vim } from './vim';
-import { AttributeTarget } from './objectAttributes';
-export declare class ColorAttribute {
+import { WebglAttributeTarget } from './webglAttribute';
+export declare class WebglColorAttribute {
     readonly vim: Vim;
     private _meshes;
     private _value;
-    constructor(meshes: AttributeTarget[] | undefined, value: THREE.Color | undefined, vim: Vim | undefined);
-    updateMeshes(meshes: AttributeTarget[] | undefined): void;
+    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;
     /**

package/dist/types/core-viewers/webgl/loader/{object3D.d.ts → element3d.d.ts}

@@ -5,22 +5,23 @@ import * as THREE from 'three';
 import { Vim } from './vim';
 import { IElement, VimHelpers } from 'vim-format';
 import { Submesh } from './mesh';
+import { IVimElement } from '../../shared/vim';
 /**
  * High level api to interact with the loaded vim geometry and data.
  */
-export declare class Object3D {
+export declare class Element3D implements IVimElement {
     private _color;
     private _boundingBox;
     private _meshes;
-    private _outlineAttribute;
-    private _visibleAttribute;
-    private _coloredAttribute;
-    private _focusedAttribute;
-    private _colorAttribute;
+    private readonly _outlineAttribute;
+    private readonly _visibleAttribute;
+    private readonly _coloredAttribute;
+    private readonly _focusedAttribute;
+    private readonly _colorAttribute;
     /**
      * Indicate whether this object is architectural or markup.
      */
-    readonly type = "Object3D";
+    readonly type = "Element3D";
     /**
      * The vim object from which this object came from.
      */
@@ -42,6 +43,7 @@ export declare class Object3D {
      * @returns {boolean} True if this object has geometry, otherwise false.
      */
     get hasMesh(): boolean;
+    get isRoom(): boolean;
     /**
      * Determines whether to render selection outline for this object or not.
      */
@@ -64,6 +66,7 @@ export declare class Object3D {
      */
     get color(): THREE.Color | undefined;
     set color(color: THREE.Color | undefined);
+    private get renderer();
     /**
      * Constructs a new instance of Object.
      * @param {Vim} vim The Vim instance.
@@ -87,14 +90,14 @@ export declare class Object3D {
      * Returns undefined if the object has no geometry.
      * @returns {THREE.Box3 | undefined} The bounding box of the object, or undefined if the object has no geometry.
      */
-    getBoundingBox(): THREE.Box3;
+    getBoundingBox(): Promise<THREE.Box3>;
     /**
      * Retrieves the center position of this object.
      * @param {THREE.Vector3} [target=new THREE.Vector3()] Optional parameter specifying where to copy the center position data.
      * A new instance is created if none is provided.
      * @returns {THREE.Vector3 | undefined} The center position of the object, or undefined if the object has no geometry.
      */
-    getCenter(target?: THREE.Vector3): THREE.Vector3;
+    getCenter(target?: THREE.Vector3): Promise<THREE.Vector3>;
     /**
      * Internal method used to replace this object's meshes and apply color as needed.
      * @param {Submesh} mesh The new mesh to be added.