vim-web 0.5.1 → 0.6.0-dev.1

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

@@ -1,4 +1,5 @@
 export * from './inputHandler';
+export * from './loadResult';
 export { PointerMode } from './inputHandler';
 export type * from './baseInputHandler';
 export type * from './keyboardHandler';
@@ -7,3 +8,4 @@ export type * from './raycaster';
 export type * from './selection';
 export type * from './touchHandler';
 export type * from './vim';
+export type * from './vimCollection';

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

@@ -18,5 +18,5 @@ export interface IInputAdapter {
     mouseMove: (pos: THREE.Vector2) => void;
     selectAtPointer: (pos: THREE.Vector2, add: boolean) => void;
     frameAtPointer: (pos: THREE.Vector2) => void;
-    zoom: (value: number) => void;
+    zoom: (value: number, pos?: THREE.Vector2) => void;
 }

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

@@ -0,0 +1,55 @@
+export interface ILoadSuccess<T> {
+    readonly isSuccess: true;
+    readonly isError: false;
+    readonly vim: T;
+}
+export interface ILoadError {
+    readonly isSuccess: false;
+    readonly isError: true;
+    readonly error: string;
+    readonly details?: string;
+}
+export type ProgressType = 'bytes' | 'percent';
+export interface IProgress {
+    type: ProgressType;
+    current: number;
+    total?: number;
+}
+export type LoadResult<TValue, TError extends ILoadError = ILoadError> = ILoadSuccess<TValue> | TError;
+export declare class LoadSuccess<T> implements ILoadSuccess<T> {
+    readonly vim: T;
+    readonly isSuccess: true;
+    readonly isError: false;
+    constructor(vim: T);
+}
+export declare class LoadError implements ILoadError {
+    readonly error: string;
+    readonly details?: string;
+    readonly isSuccess: false;
+    readonly isError: true;
+    constructor(error: string, details?: string);
+}
+/**
+ * Interface for load requests that can be used as a type constraint.
+ */
+export interface ILoadRequest<TVim, TError extends ILoadError = ILoadError> {
+    readonly isCompleted: boolean;
+    getProgress(): AsyncGenerator<IProgress>;
+    getResult(): Promise<LoadResult<TVim, TError>>;
+    abort(): void;
+}
+/**
+ * Base class for loading requests that provides progress tracking via AsyncQueue.
+ * Both WebGL and Ultra extend this class with their specific loading logic.
+ */
+export declare class LoadRequest<TVim, TError extends ILoadError = ILoadError> implements ILoadRequest<TVim, TError> {
+    private _progressQueue;
+    private _result;
+    private _resultPromise;
+    get isCompleted(): boolean;
+    getProgress(): AsyncGenerator<IProgress>;
+    getResult(): Promise<LoadResult<TVim, TError>>;
+    pushProgress(progress: IProgress): void;
+    complete(result: LoadResult<TVim, TError>): void;
+    abort(): void;
+}

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

@@ -13,7 +13,7 @@ export declare class MouseHandler extends BaseInputHandler {
     onDrag: DragCallback;
     onClick: (position: THREE.Vector2, ctrl: boolean) => void;
     onDoubleClick: (position: THREE.Vector2) => void;
-    onWheel: (value: number, ctrl: boolean) => void;
+    onWheel: (value: number, ctrl: boolean, pos: THREE.Vector2) => void;
     onContextMenu: (position: THREE.Vector2) => void;
     constructor(canvas: HTMLCanvasElement);
     protected addListeners(): void;

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

@@ -15,13 +15,13 @@ export interface IRaycaster<T> {
     /**
      * Raycasts from camera to the screen position to find the first object hit.
      * @param position - The screen position to raycast from.
-     * @returns A promise that resolves to the raycast result.
+     * @returns A promise that resolves to the raycast result, or undefined if no hit.
      */
-    raycastFromScreen(position: THREE.Vector2): Promise<IRaycastResult<T>>;
+    raycastFromScreen(position: THREE.Vector2): Promise<IRaycastResult<T> | undefined>;
     /**
      * Raycasts from camera to world position to find the first object hit.
-     * @param position - The world position to raycast from.
-     * @returns A promise that resolves to the raycast result.
+     * @param position - The world position to raycast through.
+     * @returns A promise that resolves to the raycast result, or undefined if no hit.
      */
-    raycastFromWorld(position: THREE.Vector3): Promise<IRaycastResult<T>>;
+    raycastFromWorld(position: THREE.Vector3): Promise<IRaycastResult<T> | undefined>;
 }

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

@@ -0,0 +1,25 @@
+import { ISignal } from 'ste-signals';
+import { IVim, IVimElement } from './vim';
+/**
+ * Readonly interface for a collection of vims.
+ */
+export interface IReadonlyVimCollection<T extends IVim<IVimElement>> {
+    /** Number of vims in the collection */
+    readonly count: number;
+    /** Signal dispatched when collection changes */
+    readonly onChanged: ISignal;
+    /** Get vim by its stable ID */
+    getFromId(id: number): T | undefined;
+    /** Get all vims as an array */
+    getAll(): ReadonlyArray<T>;
+    /** Check if vim is in collection */
+    has(vim: T): boolean;
+}
+/**
+ * Mutable interface for a collection of vims.
+ */
+export interface IVimCollection<T extends IVim<IVimElement>> extends IReadonlyVimCollection<T> {
+    add(vim: T): void;
+    remove(vim: T): void;
+    clear(): void;
+}

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

@@ -1,35 +1,13 @@
 import { Vim } from './vim';
-export type LoadRequestResult = LoadSuccess | LoadError;
-export declare class LoadSuccess {
-    readonly isError = false;
-    readonly isSuccess = true;
-    readonly vim: Vim;
-    constructor(vim: Vim);
-}
-export declare class LoadError {
-    error: VimRequestErrorType;
-    readonly isError = true;
-    readonly isSuccess = false;
+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;
-    readonly details: string | undefined;
     constructor(error: VimRequestErrorType, details?: string);
 }
-export interface ILoadRequest {
-    get isCompleted(): boolean;
-    getProgress(): AsyncGenerator<number>;
-    getResult(): Promise<LoadError | LoadSuccess>;
-    abort(): void;
-}
-export type VimRequestErrorType = 'loadingError' | 'downloadingError' | 'serverDisconnected' | 'unknown' | 'cancelled';
-export declare class LoadRequest implements ILoadRequest {
-    private _progress;
-    private _progressPromise;
-    private _completionPromise;
-    private _result;
-    get isCompleted(): boolean;
-    getProgress(): AsyncGenerator<number, void, unknown>;
-    getResult(): Promise<LoadError | LoadSuccess>;
-    onProgress(progress: number): void;
+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/viewer.d.ts

@@ -3,7 +3,7 @@ import type { InputHandler } from '../shared';
 import { ICamera } from './camera';
 import { ColorManager } from './colorManager';
 import { IDecoder } from './decoder';
-import { ILoadRequest } from './loadRequest';
+import { type ILoadRequest } from './loadRequest';
 import { ILogger } from './logger';
 import { IUltraRaycaster } from './raycaster';
 import { IRenderer } from './renderer';

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

@@ -1,13 +1,11 @@
-import { ISignal } from "ste-signals";
-import { Vim } from "./vim";
-export interface IReadonlyVimCollection {
-    getFromHandle(handle: number): Vim | undefined;
-    getAll(): ReadonlyArray<Vim>;
+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;
-    count: number;
-    onChanged: ISignal;
 }
-export declare class VimCollection implements IReadonlyVimCollection {
+export declare class VimCollection implements IVimCollection<Vim>, IReadonlyVimCollection {
     private _vims;
     private _onChanged;
     get onChanged(): ISignal;
@@ -24,11 +22,17 @@ export declare class VimCollection implements IReadonlyVimCollection {
      */
     remove(vim: Vim): void;
     /**
-     * Gets a Vim instance by its handle.
-     * @param handle - The handle of the Vim instance.
+     * 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.
      */
-    getFromHandle(handle: number): Vim | undefined;
+    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.

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

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

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

@@ -1,5 +1,6 @@
-export * from './vimSettings';
-export { requestVim as request, type RequestSource, type VimRequest } from './progressive/vimRequest';
+export type { VimSettings, VimPartialSettings } from './vimSettings';
+export * from './vimCollection';
+export type { RequestSource, LoadRequest, ILoadRequest } from './progressive/loadRequest';
 export * as Materials from './materials';
 export type { Transparency } from './geometry';
 export type * from './webglAttribute';
@@ -9,7 +10,6 @@ export type * from './elementMapping';
 export type * from './mesh';
 export type * from './scene';
 export type * from './vim';
-export type * from './progressive/vimx';
 export type * from './progressive/g3dOffsets';
 export type * from './progressive/g3dSubset';
 export type * from './progressive/insertableGeometry';

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

@@ -3,6 +3,7 @@ export * from './maskMaterial';
 export * from './materials';
 export * from './mergeMaterial';
 export * from './outlineMaterial';
+export * from './pickingMaterial';
 export * from './simpleMaterial';
 export * from './skyboxMaterial';
 export * from './standardMaterial';

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

@@ -0,0 +1,42 @@
+/**
+ * @module vim-loader/materials
+ * Material for GPU picking that outputs element index, depth, and surface normal in a single pass.
+ */
+import * as THREE from 'three';
+/**
+ * Creates a material for GPU picking that outputs packed IDs, depth, and surface normal.
+ *
+ * Expects a `packedId` uint attribute pre-packed during mesh building as: (vimIndex << 24) | elementIndex
+ *
+ * Output format (Float32 RGBA):
+ * - R = packed uint as float bits - supports 256 vims × 16M elements
+ * - G = depth (distance along camera direction, 0 = miss)
+ * - B = normal.x (surface normal X component)
+ * - A = normal.y (surface normal Y component)
+ *
+ * Normal.z is reconstructed as: sqrt(1 - x² - y²), always positive since normal faces camera.
+ *
+ * @returns A custom shader material for GPU picking.
+ */
+export declare function createPickingMaterial(): THREE.ShaderMaterial;
+/**
+ * PickingMaterial class that wraps the shader material with camera update functionality.
+ */
+export declare class PickingMaterial {
+    readonly material: THREE.ShaderMaterial;
+    constructor();
+    /**
+     * Updates the camera uniforms for depth calculation.
+     * Must be called before rendering.
+     */
+    updateCamera(camera: THREE.Camera): void;
+    /**
+     * Gets or sets the clipping planes for section box support.
+     */
+    get clippingPlanes(): THREE.Plane[];
+    set clippingPlanes(planes: THREE.Plane[]);
+    /**
+     * Disposes of the material resources.
+     */
+    dispose(): void;
+}

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

@@ -5,6 +5,7 @@ import * as THREE from 'three';
 import { G3d, G3dMesh, G3dMaterial } from 'vim-format';
 import { Scene } from '../scene';
 import { G3dMeshOffsets } from './g3dOffsets';
+import { ElementMapping } from '../elementMapping';
 export declare class GeometrySubmesh {
     instance: number;
     start: number;
@@ -23,10 +24,13 @@ export declare class InsertableGeometry {
     private _indexAttribute;
     private _vertexAttribute;
     private _colorAttribute;
+    private _packedIdAttribute;
+    private _mapping;
+    private _vimIndex;
     private _updateStartMesh;
     private _updateEndMesh;
     private _meshToUpdate;
-    constructor(offsets: G3dMeshOffsets, materials: G3dMaterial, transparent: boolean);
+    constructor(offsets: G3dMeshOffsets, materials: G3dMaterial, transparent: boolean, mapping?: ElementMapping, vimIndex?: number);
     get progress(): number;
     insert(mesh: G3dMesh, at: number): number[];
     float32ArraysAreEqual(array1: Float32Array, array2: Float32Array): boolean;
@@ -34,6 +38,7 @@ export declare class InsertableGeometry {
     private setIndex;
     private setVertex;
     private setColor;
+    private setPackedId;
     private expandBox;
     flushUpdate(): void;
     update(): void;

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

@@ -8,6 +8,7 @@ import { InsertableSubmesh } from './insertableSubmesh';
 import { G3dMeshOffsets } from './g3dOffsets';
 import { Vim } from '../vim';
 import { ModelMaterial } from '../materials/materials';
+import { ElementMapping } from '../elementMapping';
 export declare class InsertableMesh {
     offsets: G3dMeshOffsets;
     mesh: THREE.Mesh;
@@ -33,7 +34,7 @@ export declare class InsertableMesh {
      */
     private _material;
     geometry: InsertableGeometry;
-    constructor(offsets: G3dMeshOffsets, materials: G3dMaterial, transparent: boolean);
+    constructor(offsets: G3dMeshOffsets, materials: G3dMaterial, transparent: boolean, mapping?: ElementMapping, vimIndex?: number);
     get progress(): number;
     insert(g3d: G3dMesh, mesh: number): void;
     insertFromVim(g3d: G3d, mesh: number): void;

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

@@ -3,9 +3,12 @@
  */
 import { G3d, G3dMesh, G3dMaterial, MeshSection } from 'vim-format';
 import { InstancedMesh } from './instancedMesh';
+import { ElementMapping } from '../elementMapping';
 export declare class InstancedMeshFactory {
     materials: G3dMaterial;
-    constructor(materials: G3dMaterial);
+    private _mapping;
+    private _vimIndex;
+    constructor(materials: G3dMaterial, mapping?: ElementMapping, vimIndex?: number);
     createTransparent(mesh: G3dMesh, instances: number[]): InstancedMesh;
     createOpaque(mesh: G3dMesh, instances: number[]): InstancedMesh;
     createOpaqueFromVim(g3d: G3d, mesh: number, instances: number[]): InstancedMesh;
@@ -17,4 +20,8 @@ export declare class InstancedMeshFactory {
     private computeVertices;
     private computeColors;
     private setMatricesFromVimx;
+    /**
+     * Adds per-instance packed ID attribute for GPU picking.
+     */
+    private setPackedIds;
 }

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

@@ -4,6 +4,7 @@
 import { Scene } from '../scene';
 import { G3dMaterial, G3d } from 'vim-format';
 import { G3dSubset } from './g3dSubset';
+import { ElementMapping } from '../elementMapping';
 /**
  * Mesh factory to load a standard vim using the progressive pipeline.
  */
@@ -12,7 +13,9 @@ export declare class VimMeshFactory {
     private _materials;
     private _instancedFactory;
     private _scene;
-    constructor(g3d: G3d, materials: G3dMaterial, scene: Scene);
+    private _mapping;
+    private _vimIndex;
+    constructor(g3d: G3d, materials: G3dMaterial, scene: Scene, mapping: ElementMapping, vimIndex?: number);
     /**
      * Adds all instances from subset to the scene
      */

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

@@ -0,0 +1,21 @@
+import { VimPartialSettings } from '../vimSettings';
+import { Vim } from '../vim';
+import { LoadRequest as BaseLoadRequest, ILoadRequest as BaseILoadRequest } from '../../../shared/loadResult';
+import { VimSource } from '../..';
+export type RequestSource = {
+    url?: string;
+    buffer?: ArrayBuffer;
+    headers?: Record<string, string>;
+};
+export type ILoadRequest = BaseILoadRequest<Vim>;
+/**
+ * A request to load a VIM file. Extends the base LoadRequest to add BFast abort handling.
+ * Loading starts immediately upon construction.
+ */
+export declare class LoadRequest extends BaseLoadRequest<Vim> {
+    private _bfast;
+    constructor(source: VimSource, settings: VimPartialSettings, vimIndex: number);
+    private startRequest;
+    private loadFromVim;
+    abort(): void;
+}

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

@@ -41,11 +41,12 @@ export declare class VimSubsetBuilder implements SubsetBuilder {
 export declare class VimxSubsetBuilder {
     private _localVimx;
     private _scene;
+    private _vimIndex;
     private _set;
     private _onUpdate;
     get onUpdate(): ISignal;
     get isLoading(): boolean;
-    constructor(localVimx: Vimx, scene: Scene);
+    constructor(localVimx: Vimx, scene: Scene, vimIndex?: number);
     getFullSet(): G3dSubset;
     loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): Promise<void>;
     clear(): void;

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

@@ -1,7 +1,8 @@
 /**
  * @module vim-loader
  */
-import { Vimx, Scene } from '../..';
+import { Scene } from '../scene';
+import { Vimx } from './vimx';
 import { G3dSubset } from './g3dSubset';
 export type LoadSettings = {
     /** Delay in ms between each rendering list update. @default: 400ms */
@@ -27,7 +28,7 @@ export declare class SubsetRequest {
     private _started;
     private _scene;
     getBoundingBox(): import("three").Box3;
-    constructor(scene: Scene, localVimx: Vimx, subset: G3dSubset);
+    constructor(scene: Scene, localVimx: Vimx, subset: G3dSubset, vimIndex?: number);
     dispose(): void;
     start(settings: LoadPartialSettings): Promise<void>;
     private nextFrame;

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

@@ -23,6 +23,11 @@ export declare class Vim implements IVim<Element3D> {
      * Useful for distinguishing between different viewer types in a multi-viewer application.
      */
     readonly type = "webgl";
+    /**
+     * The stable ID of this vim in the scene's vim collection (0-255).
+     * Used for GPU picking to identify which vim an element belongs to.
+     */
+    readonly vimIndex: number;
     /**
      * Indicates whether the vim was opened from a vim or vimx file.
      */
@@ -81,13 +86,13 @@ export declare class Vim implements IVim<Element3D> {
    * @param {G3d | undefined} g3d - The G3d object, if available.
    * @param {Scene} scene - The scene containing the vim's geometry.
    * @param {VimSettings} settings - The settings used to open this vim.
+   * @param {number} vimIndex - The stable ID of this vim (0-255) for GPU picking.
    * @param {ElementMapping | ElementNoMapping | ElementMapping2} map - The element mapping.
    * @param {SubsetBuilder} builder - The subset builder for constructing subsets of the Vim object.
    * @param {string} source - The source of the Vim object.
    * @param {VimFormat} format - The format of the Vim object.
-   * @param {boolean} isLegacy - Indicates whether the Vim object uses a legacy loading pipeline.
    */
-    constructor(header: VimHeader | undefined, document: VimDocument, g3d: G3d | undefined, scene: Scene, settings: VimSettings, map: ElementMapping | ElementNoMapping | ElementMapping2, builder: SubsetBuilder, source: string, format: VimFormat);
+    constructor(header: VimHeader | undefined, document: VimDocument, g3d: G3d | undefined, scene: Scene, settings: VimSettings, vimIndex: number, map: ElementMapping | ElementNoMapping | ElementMapping2, builder: SubsetBuilder, source: string, format: VimFormat);
     getBoundingBox(): Promise<THREE.Box3>;
     /**
      * Retrieves the matrix representation of the Vim object's position, rotation, and scale.

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

@@ -0,0 +1,78 @@
+/**
+ * @module vim-loader
+ */
+import { ISignal } from 'ste-signals';
+import { IVimCollection } from '../../shared/vimCollection';
+import { Vim } from './vim';
+/**
+ * Maximum number of vims that can be loaded simultaneously.
+ * Limited by the 8-bit vimIndex in GPU picking (256 values: 0-255).
+ */
+export declare const MAX_VIMS = 256;
+/**
+ * Manages a collection of Vim objects with stable IDs for GPU picking.
+ *
+ * Each vim is assigned a stable ID (0-255) that persists for its lifetime.
+ * IDs are allocated sequentially and only reused after all 256 have been used.
+ * This ensures GPU picker can correctly identify vims even after removals.
+ */
+export declare class VimCollection implements IVimCollection<Vim> {
+    private _vimsById;
+    private _nextId;
+    private _freedIds;
+    private _count;
+    private _onChanged;
+    /**
+     * Signal dispatched when collection changes (add/remove/clear).
+     */
+    get onChanged(): ISignal;
+    /**
+     * Allocates a stable ID for a new vim.
+     * Fresh IDs are allocated sequentially (0, 1, 2, ..., 255).
+     * Freed IDs are only reused after all 256 have been allocated once.
+     * @returns The allocated ID, or undefined if all 256 IDs are in use
+     */
+    allocateId(): number | undefined;
+    /**
+     * Whether the collection has reached maximum capacity (256 vims).
+     */
+    get isFull(): boolean;
+    /**
+     * The number of vims currently in the collection.
+     */
+    get count(): number;
+    /**
+     * Adds a vim to the collection using its vimIndex as the ID.
+     * The vim's vimIndex should have been allocated via allocateId().
+     * @param vim The vim to add
+     * @throws Error if the vim's vimIndex slot is already occupied
+     */
+    add(vim: Vim): void;
+    /**
+     * Removes a vim from the collection and frees its ID for reuse.
+     * @param vim The vim to remove
+     * @throws Error if the vim is not in the collection
+     */
+    remove(vim: Vim): void;
+    /**
+     * Gets a vim by its stable ID.
+     * @param id The stable ID (0-255)
+     * @returns The vim at that ID, or undefined if empty
+     */
+    getFromId(id: number): Vim | undefined;
+    /**
+     * Checks if a vim is in the collection.
+     * @param vim The vim to check
+     * @returns True if the vim is in the collection
+     */
+    has(vim: Vim): boolean;
+    /**
+     * Returns all vims as a packed array (for iteration).
+     * @returns Array of all vims currently in the collection
+     */
+    getAll(): Vim[];
+    /**
+     * Clears all vims from the collection and resets ID allocation.
+     */
+    clear(): void;
+}

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

@@ -3,7 +3,7 @@
  */
 import { Transparency } from './geometry';
 import * as THREE from 'three';
-export type FileType = 'vim' | 'vimx' | undefined;
+type FileType = 'vim' | 'vimx' | undefined;
 /**
  * Represents settings for configuring the behavior and rendering of a vim object.
  */
@@ -33,6 +33,12 @@ export type VimSettings = {
      * Set to true to enable verbose HTTP logging.
      */
     verboseHttp: boolean;
+};
+/**
+ * Internal settings type that includes vimx-specific fields.
+ * Used internally for loading vimx files.
+ */
+export type VimSettingsFull = VimSettings & {
     /**
      * Specifies the file type (vim or vimx) if it cannot or should not be inferred from the file extension.
      */
@@ -49,7 +55,7 @@ export type VimSettings = {
 /**
  * Default configuration settings for a vim object.
  */
-export declare function getDefaultVimSettings(): VimSettings;
+export declare function getDefaultVimSettings(): VimSettingsFull;
 /**
  * Represents a partial configuration of settings for a vim object.
  */
@@ -57,6 +63,7 @@ export type VimPartialSettings = Partial<VimSettings>;
 /**
  * Wraps Vim options, converting values to related THREE.js types and providing default values.
  * @param {VimPartialSettings} [options] - Optional partial settings for the Vim object.
- * @returns {VimSettings} The complete settings for the Vim object, including defaults.
+ * @returns {VimSettingsFull} The complete settings for the Vim object, including defaults.
  */
-export declare function createVimSettings(options?: VimPartialSettings): VimSettings;
+export declare function createVimSettings(options?: VimPartialSettings): VimSettingsFull;
+export {};

package/dist/types/core-viewers/webgl/viewer/camera/cameraMovement.d.ts

@@ -39,6 +39,14 @@ export declare abstract class CameraMovement {
      * @param {number} amount - The factor by which to change the distance (e.g., 0.5 for halving the distance, 2 for doubling the distance).
      */
     abstract zoom(amount: number): void;
+    /**
+     * Zooms toward a specific point, making it the new orbit target.
+     * Preserves the camera's forward direction while moving closer/farther from the point.
+     * If point is undefined, falls back to regular zoom.
+     * @param {THREE.Vector3 | undefined} point - The world position to zoom toward, or undefined for regular zoom
+     * @param {number} amount - The zoom factor (< 1 zooms in, > 1 zooms out)
+     */
+    zoomTo(point: THREE.Vector3 | undefined, amount: number): void;
     /**
      * Sets the distance between the camera and its target to the specified value.
      * @param {number} dist - The new distance between the camera and its target.