vim-web 0.3.44-dev.7 → 0.3.44-dev.70

package/README.md

@@ -11,11 +11,11 @@ https://www.npmjs.com/package/vim-web
 
 ### WebGL Viewer
 - **[Small - Residence](https://vimaec.github.io/vim-web/webgl)**
-- **[Medium - Medical Tower](https://vimaec.github.io/vim-web/webgl?vim=https://vim.azureedge.net/samples/Medical_Tower.vim)**
+- **[Medium - Medical Tower](https://vimaec.github.io/vim-web/webgl?vim=https://storage.cdn.vimaec.com/samples/Medical_Tower.vim)**
 
 ### Ultra Viewer
 - **[Small - Residence](https://vimaec.github.io/vim-web/ultra)**
-- **[Medium - Medical Tower](https://vimaec.github.io/vim-web/ultra?vim=https://vim.azureedge.net/samples/Medical_Tower.vim)**
+- **[Medium - Medical Tower](https://vimaec.github.io/vim-web/ultra?vim=https://storage.cdn.vimaec.com/samples/Medical_Tower.vim)**
 
 Find detailed camera controls here: [Camera Controls](https://docs.vimaec.com/docs/vim-cloud/webgl-navigation-and-controls-guide).
 

package/dist/style.css

@@ -733,6 +733,9 @@ video:where(.vim-component,.vim-component *) {
 .vc-top-1 {
   top: 0.25rem;
 }
+.vc-top-10 {
+  top: 2.5rem;
+}
 .vc-top-4 {
   top: 1rem;
 }
@@ -845,6 +848,9 @@ video:where(.vim-component,.vim-component *) {
 .vc-hidden {
   display: none;
 }
+.vc-h-1\/2 {
+  height: 50%;
+}
 .vc-h-2 {
   height: 0.5rem;
 }
@@ -982,6 +988,9 @@ video:where(.vim-component,.vim-component *) {
 .vc-justify-evenly {
   justify-content: space-evenly;
 }
+.vc-gap-1 {
+  gap: 0.25rem;
+}
 .vc-gap-2 {
   gap: 0.5rem;
 }
@@ -1098,6 +1107,9 @@ video:where(.vim-component,.vim-component *) {
   --tw-bg-opacity: 1 !important;
   background-color: rgb(255 255 255 / var(--tw-bg-opacity, 1)) !important;
 }
+.vc-bg-gray {
+  background-color: var(--c-gray);
+}
 .vc-bg-gray-light {
   background-color: var(--c-light-gray);
 }
@@ -1110,9 +1122,6 @@ video:where(.vim-component,.vim-component *) {
 .vc-bg-gray-warm {
   background-color: var(--c-dark-gray-warm);
 }
-.vc-bg-overflow {
-  background-color: var(--c-overflow);
-}
 .vc-bg-primary {
   background-color: var(--c-primary);
 }
@@ -1304,11 +1313,6 @@ video:where(.vim-component,.vim-component *) {
   --tw-saturate: saturate(0);
   filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
 }
-.vc-backdrop-blur {
-  --tw-backdrop-blur: blur(8px);
-  -webkit-backdrop-filter: var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);
-  backdrop-filter: var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);
-}
 .\!vc-transition-opacity {
   transition-property: opacity !important;
   transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1) !important;
@@ -1514,7 +1518,7 @@ video:where(.vim-component,.vim-component *) {
     padding-left:  min(2cqmin, 1rem);
     padding-right:  min(2cqmin, 1rem);
   }
-  
+
   .vim-control-bar-button {
     height: min(8cqmin, 2.5rem);
     width: min(8cqmin, 2.5rem);
@@ -1522,6 +1526,18 @@ video:where(.vim-component,.vim-component *) {
   .vim-control-bar-section {
     gap: min(2cqmin, 0.5rem)
   }
+
+  .vim-rest-of-screen .vc-text-xs {
+    font-size: min(2.0cqmin, 0.75rem);
+    line-height: min(2.5cqmin, 0.85rem);
+  }
+
+  .vim-control-bar-counter{
+    margin-bottom: min(1cqmin, 0.5rem);
+    margin-right: min(2cqmin, 0.5rem);
+    margin-left: max(-2cqmin, -0.75rem);
+  }
+
   .vim-axes-panel{
     border-radius: min(3cqmin, 1rem);
     top: min(2cqmin, 1.5rem);

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

@@ -0,0 +1,3 @@
+export * as Webgl from './webgl';
+export * as Ultra from './ultra';
+export * from './shared';

package/dist/types/core-viewers/{webgl/viewer/inputs/inputHandler.d.ts → shared/baseInputHandler.d.ts}

@@ -1,16 +1,16 @@
 /**
  * @module viw-webgl-viewer/inputs
  */
-import { Viewer } from '../viewer';
 /**
+ * TODO: Use the same code for ULTRA and webgl.
  * Base class for various input handlers.
  * It provides convenience to register to and unregister from events.
  */
-export declare class InputHandler {
-    protected _viewer: Viewer;
-    protected _unregisters: Function[];
-    constructor(viewer: Viewer);
-    protected reg: (handler: Document | HTMLElement | Window, type: string, listener: (event: any) => void) => void;
+export declare class BaseInputHandler {
+    protected _canvas: HTMLCanvasElement;
+    protected _disconnect: Function[];
+    constructor(canvas: HTMLCanvasElement);
+    protected reg<T extends Event>(element: Document | HTMLElement | Window, eventType: string, callback: (event: T) => void): void;
     /**
      * Register handler to related browser events
      * Prevents double registrations

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

@@ -0,0 +1,9 @@
+export * from './inputHandler';
+export type * from './baseInputHandler';
+export { PointerMode } from './inputHandler';
+export type * from './keyboardHandler';
+export type * from './mouseHandler';
+export type * from './raycaster';
+export type * from './selection';
+export type * from './touchHandler';
+export type * from './vim';

package/dist/types/core-viewers/shared/inputHandler.d.ts

@@ -0,0 +1,116 @@
+import * as THREE from 'three';
+import { BaseInputHandler } from './baseInputHandler';
+import { KeyboardHandler } from './keyboardHandler';
+import { MouseHandler } from './mouseHandler';
+import { TouchHandler } from './touchHandler';
+export declare enum PointerMode {
+    ORBIT = "orbit",
+    LOOK = "look",
+    PAN = "pan",
+    ZOOM = "zoom",
+    RECT = "rect"
+}
+export interface IInputAdapter {
+    init: () => void;
+    toggleOrthographic: () => void;
+    resetCamera: () => void;
+    clearSelection: () => void;
+    frameCamera: () => void;
+    moveCamera: (value: THREE.Vector3) => void;
+    orbitCamera: (value: THREE.Vector2) => void;
+    rotateCamera: (value: THREE.Vector2) => void;
+    panCamera: (value: THREE.Vector2) => void;
+    keyDown: (keyCode: string) => boolean;
+    keyUp: (keyCode: string) => boolean;
+    mouseDown: (pos: THREE.Vector2, button: number) => void;
+    mouseUp: (pos: THREE.Vector2, button: number) => void;
+    mouseMove: (pos: THREE.Vector2) => void;
+    selectAtPointer: (pos: THREE.Vector2, add: boolean) => void;
+    frameAtPointer: (pos: THREE.Vector2) => void;
+    zoom: (value: number) => void;
+}
+interface InputSettings {
+    orbit: boolean;
+    scrollSpeed: number;
+    moveSpeed: number;
+    rotateSpeed: number;
+    orbitSpeed: number;
+}
+export declare class InputHandler extends BaseInputHandler {
+    /**
+     * Touch input handler
+     */
+    touch: TouchHandler;
+    /**
+     * Mouse input handler
+     */
+    mouse: MouseHandler;
+    /**
+     * Keyboard input handler
+     */
+    keyboard: KeyboardHandler;
+    scrollSpeed: number;
+    private _moveSpeed;
+    rotateSpeed: number;
+    orbitSpeed: number;
+    private _pointerActive;
+    private _pointerFallback;
+    private _pointerOverride;
+    private _onPointerOverrideChanged;
+    private _onPointerModeChanged;
+    private _onSettingsChanged;
+    private _adapter;
+    constructor(canvas: HTMLCanvasElement, adapter: IInputAdapter, settings?: Partial<InputSettings>);
+    init(): void;
+    get moveSpeed(): number;
+    set moveSpeed(value: number);
+    get onSettingsChanged(): import("ste-signals").ISignal;
+    /**
+     * Returns the last main mode (orbit, look) that was active.
+     */
+    get pointerFallback(): PointerMode;
+    /**
+     * Returns current pointer mode.
+     */
+    get pointerActive(): PointerMode;
+    /**
+     * A temporary pointer mode used for temporary icons.
+     */
+    get pointerOverride(): PointerMode;
+    set pointerOverride(value: PointerMode | undefined);
+    /**
+     * Changes pointer interaction mode. Look mode will set camera orbitMode to false.
+     */
+    set pointerActive(value: PointerMode);
+    /**
+     * Event called when pointer interaction mode changes.
+     */
+    get onPointerModeChanged(): import("ste-signals").ISignal;
+    /**
+     * Event called when the pointer is temporarily overriden.
+     */
+    get onPointerOverrideChanged(): import("ste-signals").ISignal;
+    private _onContextMenu;
+    /**
+     * Event called when when context menu could be displayed
+     */
+    get onContextMenu(): import("ste-simple-events").ISimpleEvent<THREE.Vector2>;
+    /**
+     * Calls context menu action
+     */
+    ContextMenu(position: THREE.Vector2 | undefined): void;
+    /**
+   * Register inputs handlers for default viewer behavior
+   */
+    registerAll(): void;
+    /**
+     * Unregisters all input handlers
+     */
+    unregisterAll: () => void;
+    /**
+     * Resets all input state
+     */
+    resetAll(): void;
+    dispose(): void;
+}
+export {};

package/dist/types/core-viewers/shared/keyboardHandler.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @module viw-webgl-viewer/inputs
+ */
+import * as THREE from 'three';
+import { BaseInputHandler } from './baseInputHandler';
+type CallbackMode = 'replace' | 'append' | 'prepend';
+/**
+ * KeyboardHandler
+ *
+ * A modern keyboard handler that manages keyboard events using a stateful pattern.
+ * It supports separate handlers for key down, key up, and continuous key pressed events.
+ * The handler calculates a movement vector based on currently pressed keys.
+ */
+export declare class KeyboardHandler extends BaseInputHandler {
+    /**
+     * Callback invoked whenever the calculated movement vector is updated.
+     */
+    onMove: (value: THREE.Vector3) => void;
+    onKeyUp: (code: string) => boolean;
+    onKeyDown: (code: string) => boolean;
+    /**
+     * Speed multiplier applied when the Shift key is held.
+     * @private
+     */
+    private readonly SHIFT_MULTIPLIER;
+    /**
+     * Set of currently pressed key codes.
+     * @private
+     */
+    private pressedKeys;
+    /**
+     * Map of key down event handlers (invoked once on key down).
+     * @private
+     */
+    private keyDownHandlers;
+    /**
+     * Map of key up event handlers (invoked once on key up).
+     * @private
+     */
+    private keyUpHandlers;
+    /**
+     * Creates an instance of KeyboardHandler.
+     * @param canvas The HTMLCanvasElement to attach keyboard events to.
+     */
+    constructor(canvas: HTMLCanvasElement);
+    /**
+     * Registers the necessary keyboard event listeners.
+     * @protected
+     */
+    protected addListeners(): void;
+    private registerMovementHandlers;
+    /**
+     * Checks if a key is currently pressed.
+     * @param key The event.code of the key.
+     * @returns {boolean} True if the key is pressed, false otherwise.
+     * @private
+     */
+    isKeyPressed(key: string): boolean;
+    /**
+     * Resets the handler state by clearing all pressed keys and recalculating movement.
+     * @override
+     */
+    reset(): void;
+    /**
+     * Registers a handler for a key down event.
+     * @param code The event.code of the key.
+     * @param handler Callback invoked on key down.
+     */
+    registerKeyDown(code: string, mode: CallbackMode, handler: () => void): void;
+    /**
+     * Registers a handler for a key up event.
+     * @param code The event.code of the key.
+     * @param handler Callback invoked on key up.
+     */
+    registerKeyUp(code: string, mode: CallbackMode, handler: () => void): void;
+    private registerKey;
+    /**
+     * Internal key down event handler.
+     * @param event The KeyboardEvent object.
+     * @private
+     */
+    private _onKeyDown;
+    /**
+     * Internal key up event handler.
+     * @param event The KeyboardEvent object.
+     * @private
+     */
+    private _onKeyUp;
+    /**
+     * Calculates and applies the movement vector based on currently pressed keys.
+     * Also calls any continuous key pressed handlers for keys that are held down.
+     * @private
+     */
+    private applyMove;
+}
+export {};

package/dist/types/core-viewers/shared/mouseHandler.d.ts

@@ -0,0 +1,26 @@
+import { BaseInputHandler } from "./baseInputHandler";
+import * as THREE from 'three';
+type DragCallback = (delta: THREE.Vector2, button: number) => void;
+export declare class MouseHandler extends BaseInputHandler {
+    private _lastMouseDownPosition;
+    private _capture;
+    private _dragHandler;
+    onButtonDown: (pos: THREE.Vector2, button: number) => void;
+    onButtonUp: (pos: THREE.Vector2, button: number) => void;
+    onMouseMove: (event: THREE.Vector2) => void;
+    onDrag: DragCallback;
+    onClick: (position: THREE.Vector2, ctrl: boolean) => void;
+    onDoubleClick: (position: THREE.Vector2) => void;
+    onWheel: (value: number, ctrl: boolean) => void;
+    constructor(canvas: HTMLCanvasElement);
+    protected addListeners(): void;
+    dispose(): void;
+    private onPointerDown;
+    private onPointerUp;
+    private handleMouseClick;
+    private onPointerMove;
+    private _onDoubleClick;
+    private onMouseScroll;
+    private relativePosition;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { THREE } from "../..";
+export interface IRaycastResult<T> {
+    /** The model Object hit */
+    object: T | undefined;
+    /** The 3D world position of the hit point */
+    worldPosition: THREE.Vector3;
+    /** The surface normal at the hit point */
+    worldNormal: THREE.Vector3;
+}
+export interface IRaycaster<T> {
+    raycastFromScreen(position: THREE.Vector2): Promise<IRaycastResult<T>>;
+    raycastFromWorld(position: THREE.Vector3): Promise<IRaycastResult<T>>;
+}

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

@@ -0,0 +1,105 @@
+import { ISignal } from "ste-signals";
+import { IVimObject, IVim } from "./vim";
+import { THREE } from "../..";
+export interface ISelectionAdapter<T extends IVimObject> {
+    outline(object: T, state: boolean): void;
+}
+/**
+ * Represents a selection manager that supports adding, removing, toggling, and querying selected objects.
+ * The selection change signal is debounced to dispatch only once per animation frame.
+ */
+export declare class Selection<T extends IVimObject> {
+    private _onSelectionChanged;
+    private _selection;
+    private _adapter;
+    /**
+     * If true, reselecting the currently selected single object will toggle it instead of doing nothing.
+     */
+    toggleOnRepeatSelect: boolean;
+    /**
+     * If true, the selection manager is enabled and can modify the selection.
+     */
+    enabled: boolean;
+    /**
+     * Creates a new Selection manager.
+     * @param adapter - Adapter responsible for visual selection feedback.
+     */
+    constructor(adapter: ISelectionAdapter<T>);
+    /**
+     * Checks whether a specific object is currently selected.
+     * @param object - The object to check.
+     * @returns `true` if the object is selected; otherwise, `false`.
+     */
+    has(object: T): boolean;
+    /**
+     * Returns the number of selected objects.
+     * @returns The count of selected items.
+     */
+    count(): number;
+    /**
+     * Checks if there is at least one selected object.
+     * @returns `true` if the selection is not empty.
+     */
+    any(): boolean;
+    /**
+     * Signal that fires when the selection changes.
+     */
+    get onSelectionChanged(): ISignal;
+    /**
+     * Normalizes a value to an array of objects.
+     * @param oneOrMore - A single object or an array of objects.
+     * @returns An array of objects.
+     */
+    private toArray;
+    /**
+     * Replaces the current selection with the given object(s).
+     * If `toggleOnRepeatSelect` is true and the object is already the only selected one, it toggles it instead.
+     * @param objectOrObjects - Object(s) to select, or `undefined` to clear the selection.
+     */
+    select(object: T): void;
+    select(objects: T[]): void;
+    /**
+     * Toggles the selection state of the given object(s).
+     * @param objectOrObjects - Object(s) to toggle.
+     */
+    toggle(object: T): void;
+    toggle(objects: T[]): void;
+    /**
+     * Adds the given object(s) to the selection.
+     * @param objectOrObjects - Object(s) to add.
+     */
+    add(object: T): void;
+    add(objects: T[]): void;
+    /**
+     * Removes the given object(s) from the selection.
+     * @param objectOrObjects - Object(s) to remove.
+     */
+    remove(object: T): void;
+    remove(objects: T[]): void;
+    /**
+     * Clears the entire selection.
+     */
+    clear(): void;
+    /**
+     * Returns an array of all currently selected objects.
+     * @returns An array of selected objects.
+     */
+    getAll(): T[];
+    /**
+     * Returns all selected objects belonging to a specific VIM model.
+     * @param vim - The VIM instance to filter by.
+     * @returns An array of selected objects from the specified VIM.
+     */
+    getFromVim(vim: IVim<T>): T[];
+    /**
+     * Removes all selected objects that belong to a specific VIM model.
+     * @param vim - The VIM instance to remove selections from.
+     */
+    removeFromVim(vim: IVim<T>): void;
+    /**
+     * Computes the bounding box that contains all selected objects.
+     * Skips objects that do not implement `getBoundingBox()`.
+     * @returns A promise resolving to the combined bounding box.
+     */
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
+}

package/dist/types/core-viewers/{webgl/viewer/inputs → shared}/touchHandler.d.ts

@@ -1,28 +1,23 @@
 /**
  * @module viw-webgl-viewer/inputs
  */
-import { InputHandler } from './inputHandler';
-import { Viewer } from '../viewer';
+import * as THREE from 'three';
+import { BaseInputHandler } from './baseInputHandler';
 /**
  * Manages user touch inputs.
  */
-export declare class TouchHandler extends InputHandler {
+export declare class TouchHandler extends BaseInputHandler {
     private readonly TAP_DURATION_MS;
     private readonly DOUBLE_TAP_DELAY_MS;
     private readonly TAP_MAX_MOVE_PIXEL;
     private readonly ZOOM_SPEED;
     private readonly MOVE_SPEED;
-    /**
-     * Speed factor for rotation movements
-     */
-    rotateSpeed: number;
-    /**
-     * Speed factor for orbit movements
-     */
-    orbitSpeed: number;
-    constructor(viewer: Viewer);
-    private get camera();
-    private get viewport();
+    onTap: (position: THREE.Vector2) => void;
+    onDoubleTap: (position: THREE.Vector2) => void;
+    onDrag: (delta: THREE.Vector2) => void;
+    onDoubleDrag: (delta: THREE.Vector2) => void;
+    onPinchOrSpread: (delta: number) => void;
+    constructor(canvas: HTMLCanvasElement);
     private _touch;
     private _touch1;
     private _touch2;
@@ -31,15 +26,17 @@ export declare class TouchHandler extends InputHandler {
     private _touchStart;
     protected addListeners(): void;
     reset: () => void;
-    private onTap;
+    private _onTap;
     private onTouchStart;
     private toRotation;
-    private onDrag;
-    private onDoubleDrag;
-    private onPinchOrSpread;
     private onTouchMove;
     private onTouchEnd;
     private isSingleTouch;
     private touchToVector;
     private average;
+    /**
+     * Returns the pixel size of the canvas.
+     * @returns {THREE.Vector2} The pixel size of the canvas.
+     */
+    getCanvasSize(): THREE.Vector2;
 }

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

@@ -0,0 +1,35 @@
+import { THREE } from "../..";
+export interface IVimObject {
+    vim: IVim<IVimObject>;
+    getBoundingBox(): Promise<THREE.Box3>;
+}
+export interface IVim<T extends IVimObject> {
+    /**
+     * Retrieves the object associated with the specified instance number.
+     * @param instance - The instance number of the object.
+     * @returns The object corresponding to the instance, or undefined if not found.
+     */
+    getObjectFromInstance(instance: number): T | undefined;
+    /**
+     * Retrieves the objects associated with the specified element ID.
+     * @param id - The element ID to retrieve objects for.
+     * @returns An array of objects corresponding to the element ID.
+     */
+    getObjectsFromElementId(id: number): T[];
+    /**
+     * Retrieves the Vim object associated with the given Vim element index.
+     * @param element - The index of the Vim element.
+     * @returns The Vim object corresponding to the element index, or undefined if not found.
+     */
+    getObjectFromElementIndex(element: number): T | undefined;
+    /**
+     * Retrieves all objects within the Vim.
+     * @returns An array of all Vim objects.
+     */
+    getAllObjects(): T[];
+    /**
+     * Retrieves the bounding box of the Vim object.
+     * @returns The bounding box of the Vim object.
+     */
+    getBoundingBox(): Promise<THREE.Box3>;
+}

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

@@ -1,6 +1,8 @@
-import { Box3, Segment } from '../utils/math3d';
 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
@@ -18,7 +20,7 @@ export interface ICamera {
      * @param {number} [blendTime=0.5] - Animation duration in seconds
      * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
      */
-    frameBox(box: Box3, blendTime?: number): Promise<Segment | undefined>;
+    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
@@ -27,6 +29,13 @@ export interface ICamera {
      * @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
@@ -51,7 +60,6 @@ export interface ICamera {
 export declare class Camera implements ICamera {
     private _rpc;
     private _lastPosition;
-    private _interval;
     private _defaultBlendTime;
     private _savedPosition;
     /**
@@ -78,6 +86,7 @@ export declare class Camera implements ICamera {
      */
     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
@@ -94,7 +103,7 @@ export declare class Camera implements ICamera {
      * @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: Box3, blendTime?: number): Promise<Segment | undefined>;
+    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
@@ -103,4 +112,5 @@ export declare class Camera implements ICamera {
      * @returns Promise that resolves when the framing animation is complete
      */
     frameVim(vim: Vim, nodes: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
+    frameObject(object: Element3D, blendTime?: number): Promise<Segment | undefined>;
 }