vim-web 0.3.44-dev.42 → 0.3.44-dev.45

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

@@ -11,7 +11,7 @@ export * from '../shared/coreInputHandler';
 export * from './viewer/settings/viewerSettings';
 export * from './viewer/settings/viewerSettingsParsing';
 export * from './viewer/settings/defaultViewerSettings';
-export { RaycastResult as HitTestResult, InputAction } from './viewer/raycaster';
+export { RaycastResult as HitTestResult } from './viewer/raycaster';
 export { type SelectableObject, Selection } from './viewer/selection';
 export * from './loader/progressive/insertableMesh';
 export * from './loader/progressive/g3dSubset';

package/dist/types/core-viewers/webgl/viewer/gizmos/sectionBox/sectionBoxInputs.d.ts

@@ -28,10 +28,8 @@ export declare class BoxInputs {
     private _raycaster;
     /** The box state before the current drag. */
     private _lastBox;
-    /** A collection of unregister callbacks for event listeners. */
-    private _unregisters;
-    /** The ID of the pointer that is captured, if any. */
-    private _capturedPointerId;
+    /** A callback to restore the original input listeners after unregistering. */
+    private _restoreOriginalInputs;
     /**
      * Called when the pointer enters or leaves a handle face.
      * @param normal - The normal (forward) vector of the hovered handle, or a zero vector if none.
@@ -65,35 +63,6 @@ export declare class BoxInputs {
      * and resetting drag state.
      */
     unregister(): void;
-    /**
-     * Indicates if a pointer is currently captured for dragging.
-     */
-    get pointerCaptured(): boolean;
-    /**
-     * A helper method to attach an event listener and store its unregister callback.
-     *
-     * @param handler - The DOM element or Window to attach the listener to.
-     * @param type - The pointer event type, e.g. 'pointerdown'.
-     * @param listener - The event handler function.
-     */
-    private reg;
-    /**
-     * Called when the pointer leaves the canvas. If not dragging,
-     * invokes {@link onFaceEnter} to indicate no active handle is hovered.
-     *
-     * @param event - The pointerleave event.
-     */
-    private onPointerLeave;
-    /**
-     * Sets pointer capture on the canvas for a specific pointer (ID).
-     *
-     * @param pointerId - The pointer ID to capture.
-     */
-    private capturePointer;
-    /**
-     * Releases any captured pointer on the canvas, if present.
-     */
-    private releasePointer;
     /**
      * Handles pointer movement events.
      * - If dragging, calls {@link onDrag}.

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

@@ -4,26 +4,26 @@
 import * as THREE from 'three';
 import { Object3D } from '../loader/object3D';
 import { RenderScene } from './rendering/renderScene';
-import { Viewport } from './viewport';
 import { Camera } from './camera/camera';
 import { Renderer } from './rendering/renderer';
 import { GizmoMarker } from './gizmos/markers/gizmoMarker';
 /**
- * Type alias for THREE intersection array
+ * Type alias for an array of THREE.Intersection objects.
  */
 export type ThreeIntersectionList = THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
 export type ActionType = 'main' | 'double' | 'idle';
 export type ActionModifier = 'none' | 'shift' | 'ctrl';
 /**
- * Highlevel aggregate of information about a raycast result
+ * Aggregates detailed information about a raycasting result,
+ * including the intersected object and the hit details.
  */
 export declare class RaycastResult {
     object: Object3D | GizmoMarker | undefined;
     intersections: ThreeIntersectionList;
     firstHit: THREE.Intersection | undefined;
     constructor(intersections: ThreeIntersectionList);
-    private GetFirstVimHit;
-    private GetFirstMarkerHit;
+    private getFirstVimHit;
+    private getFirstMarkerHit;
     private getVimObjectFromHit;
     get isHit(): boolean;
     get distance(): number;
@@ -32,58 +32,47 @@ export declare class RaycastResult {
     get faceIndex(): number;
 }
 export declare class Raycaster {
-    private _viewport;
     private _camera;
     private _scene;
     private _renderer;
     private _raycaster;
-    constructor(viewport: Viewport, camera: Camera, scene: RenderScene, renderer: Renderer);
+    constructor(camera: Camera, scene: RenderScene, renderer: Renderer);
     /**
-     * Performs a raycast by projecting a ray from the camera position to a screen position.
-     * @param {THREE.Vector2} position - The screen position for raycasting.
+     * Performs a raycast from the camera using normalized screen coordinates.
+     * Coordinates must be within [0, 1] for both x and y.
+     * If the coordinates are out of bounds, an error is logged and an empty result is returned.
+     *
+     * @param {THREE.Vector2} position - The normalized screen position for raycasting.
      */
-    raycast2(position: THREE.Vector2): RaycastResult;
+    raycastFromScreen(position: THREE.Vector2): RaycastResult;
     private filterHits;
     /**
-     * Performs a raycast by projecting a ray from the camera position to a world position.
-     * @param {THREE.Vector3} position - The world position for raycasting.
+     * Performs a raycast from the camera towards a specified world position.
+     *
+     * @param {THREE.Vector3} position - The target world position for raycasting.
      */
-    raycast3(position: THREE.Vector3): RaycastResult;
+    raycastFromWorld(position: THREE.Vector3): RaycastResult;
     /**
-     * Performs a raycast by projecting a ray from the camera center.
+     * Performs a raycast starting from the camera's current target position.
      */
     raycastForward(): RaycastResult;
     /**
-     * Returns a THREE.Raycaster projecting a ray from camera position to screen position
+     * Creates and returns a THREE.Raycaster that casts a ray from the camera's position
+     * through the provided normalized screen coordinate (x and y in the range [0, 1]).
+     *
+     * @param {THREE.Vector2} position - The normalized screen position for raycasting.
+     * @param {THREE.Raycaster} target - Optional existing raycaster instance to update.
+     * @returns {THREE.Raycaster} A configured raycaster for performing raycasting.
      */
     fromPoint2(position: THREE.Vector2, target?: THREE.Raycaster): THREE.Raycaster;
     /**
-     * Returns a THREE.Raycaster projecting a ray from the camera position to a screen position.
-     * @param {THREE.Vector2} position - The screen position for raycasting.
-     * @returns {THREE.Raycaster} A raycaster object for performing raycasting.
+     * Creates and returns a THREE.Raycaster that casts a ray from the camera's position
+     * towards the specified world position.
+     * The ray's direction is computed as the normalized vector from the camera position to the target position.
+     *
+     * @param {THREE.Vector3} position - The world position for raycasting.
+     * @param {THREE.Raycaster} target - Optional existing raycaster instance to update.
+     * @returns {THREE.Raycaster} A configured raycaster for performing raycasting.
      */
     fromPoint3(position: THREE.Vector3, target?: THREE.Raycaster): THREE.Raycaster;
 }
-/**
- * Represents an input action with its position and modifiers.
- */
-export declare class InputAction {
-    readonly position: THREE.Vector2;
-    readonly modifier: ActionModifier;
-    readonly type: ActionType;
-    private _raycaster;
-    constructor(type: ActionType, modifier: ActionModifier, position: THREE.Vector2, raycaster: Raycaster);
-    private _raycast;
-    /**
-     * A THREE.Raycaster object for custom raycasting.
-     */
-    get raycaster(): THREE.Raycaster;
-    /**
-     * Performs raycasting for VIM objects at the current point. This operation can be computationally expensive.
-     */
-    get raycast(): RaycastResult;
-    /**
-     * Returns the object at the current point. This operation can cause a computationally expensive raycast evaluation.
-     */
-    get object(): Object3D | GizmoMarker;
-}

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

@@ -1,3 +1,3 @@
 import { CoreInputHandler } from "../../shared/coreInputHandler";
 import { Viewer } from "./viewer";
-export declare function webglInputAdapter(viewer: Viewer): CoreInputHandler;
+export declare function webglInputHandler(viewer: Viewer): CoreInputHandler;

package/dist/types/react-viewers/helpers/reactUtils.d.ts

@@ -1,40 +1,264 @@
+/**
+ * @module state-action-refs
+ *
+ * This module exports various React hooks and TypeScript interfaces to create references for state,
+ * actions, and functions. These references allow you to store and manipulate values and functions,
+ * as well as dynamically inject additional behavior (using prepend and append methods) into their call chains.
+ *
+ * The provided hooks include:
+ * - useStateRef: A state reference with event dispatching and validation.
+ * - useActionRef: A reference for an action (a function with no arguments).
+ * - useArgActionRef: A reference for an action that accepts an argument.
+ * - useFuncRef: A reference for a function returning a value.
+ * - useAsyncFuncRef: A reference for an asynchronous function.
+ * - useArgFuncRef: A reference for a function that accepts an argument and returns a value.
+ */
+/**
+ * Interface for a state reference.
+ * Provides methods to get, set, and confirm the current state.
+ */
 export interface StateRef<T> {
+    /**
+     * Returns the current state value.
+     */
     get(): T;
+    /**
+     * Updates the state to the provided value.
+     * @param value - The new state value.
+     */
     set(value: T): void;
+    /**
+     * Confirms the current state (potentially applying a confirmation transformation).
+     */
     confirm(): void;
 }
+/**
+ * A custom hook that creates a state reference.
+ * The reference provides access to the state, along with event dispatching, validation, and confirmation logic.
+ *
+ * @param initialValue - The initial state value.
+ * @returns An object implementing StateRef along with additional helper hooks.
+ */
 export declare function useStateRef<T>(initialValue: T): {
+    /**
+     * Returns the current state value.
+     */
     get(): T;
     set: (value: T) => void;
+    /**
+     * Confirms the current state by applying the confirm function and updating the state.
+     */
     confirm(): void;
-    useOnChange(on: (value: T) => (void | (() => void))): void;
+    /**
+     * Registers a callback to be invoked when the state changes.
+     * @param on - The callback function that receives the new state value.
+     */
+    useOnChange(on: (value: T) => void | (() => void)): void;
+    /**
+     * Memoizes a value based on the current state and additional dependencies.
+     * @param on - A function that computes a value based on the current state.
+     * @param deps - Optional additional dependencies.
+     * @returns The memoized value.
+     */
     useMemo<TOut>(on: (value: T) => TOut, deps?: any[]): TOut;
+    /**
+     * Sets a validation function to process any new state value before updating.
+     * @param on - A function that validates (and optionally transforms) the new state value.
+     */
     useValidate(on: (value: T) => T): void;
+    /**
+     * Sets a confirmation function to process the state value during confirmation.
+     * @param on - A function that confirms (and optionally transforms) the current state value.
+     */
     useConfirm(on: (value: T) => T): void;
 };
+/**
+ * Interface for an action reference (a function with no arguments).
+ * Provides methods to call, get, set, and inject code before or after the stored function.
+ */
 export interface ActionRef {
+    /**
+     * Invokes the stored action.
+     */
     call(): void;
+    /**
+     * Retrieves the current action function.
+     * @returns The stored action function.
+     */
     get(): () => void;
-    set(func: () => void): void;
+    /**
+     * Sets the stored action function.
+     * @param fn - The new action function.
+     */
+    set(fn: () => void): void;
+    /**
+     * Prepends a function to be executed before the stored action.
+     * @param fn - The function to run before the original action.
+     */
+    prepend(fn: () => void): void;
+    /**
+     * Appends a function to be executed after the stored action.
+     * @param fn - The function to run after the original action.
+     */
+    append(fn: () => void): void;
 }
+/**
+ * Custom hook to create an action reference.
+ *
+ * @param action - The initial action function.
+ * @returns An object implementing ActionRef.
+ */
 export declare function useActionRef(action: () => void): ActionRef;
+/**
+ * Interface for an action reference that accepts an argument.
+ * Provides methods to call with an argument, get, set, and inject code before or after the stored function.
+ */
 export interface ArgActionRef<T> {
+    /**
+     * Invokes the stored action with the provided argument.
+     * @param arg - The argument to pass to the action.
+     */
     call(arg: T): void;
-    set(func: (arg: T) => void): void;
+    /**
+     * Retrieves the current action function.
+     * @returns The stored action function.
+     */
+    get(): (arg: T) => void;
+    /**
+     * Sets the stored action function.
+     * @param fn - The new action function.
+     */
+    set(fn: (arg: T) => void): void;
+    /**
+     * Prepends a function to be executed before the stored action.
+     * @param fn - The function to run before the original action.
+     */
+    prepend(fn: (arg: T) => void): void;
+    /**
+     * Appends a function to be executed after the stored action.
+     * @param fn - The function to run after the original action.
+     */
+    append(fn: (arg: T) => void): void;
 }
+/**
+ * Custom hook to create an argument-based action reference.
+ *
+ * @param action - The initial action function that accepts an argument.
+ * @returns An object implementing ArgActionRef.
+ */
 export declare function useArgActionRef<T>(action: (arg: T) => void): ArgActionRef<T>;
+/**
+ * Interface for a function reference that returns a value.
+ * Provides methods to call, get, set, and inject code before or after the stored function.
+ */
 export interface FuncRef<T> {
+    /**
+     * Invokes the stored function and returns its value.
+     * @returns The result of the function call.
+     */
     call(): T;
-    set(func: () => T): void;
+    /**
+     * Retrieves the current function.
+     * @returns The stored function.
+     */
+    get(): () => T;
+    /**
+     * Sets the stored function.
+     * @param fn - The new function.
+     */
+    set(fn: () => T): void;
+    /**
+     * Prepends a function to be executed before the stored function.
+     * @param fn - The function to run before the original function.
+     */
+    prepend(fn: () => void): void;
+    /**
+     * Appends a function to be executed after the stored function.
+     * @param fn - The function to run after the original function.
+     */
+    append(fn: () => void): void;
 }
-export declare function useFuncRef<T>(func: () => T): FuncRef<T>;
+/**
+ * Custom hook to create a function reference.
+ *
+ * @param fn - The initial function.
+ * @returns An object implementing FuncRef.
+ */
+export declare function useFuncRef<T>(fn: () => T): FuncRef<T>;
+/**
+ * Interface for an asynchronous function reference.
+ * Provides methods to call, get, set, and inject code before or after the stored async function.
+ */
 export interface AsyncFuncRef<T> {
+    /**
+     * Invokes the stored asynchronous function and returns a promise of its result.
+     * @returns A promise resolving to the result of the async function.
+     */
     call(): Promise<T>;
-    set(func: () => Promise<T>): void;
+    /**
+     * Retrieves the current asynchronous function.
+     * @returns The stored async function.
+     */
+    get(): () => Promise<T>;
+    /**
+     * Sets the stored asynchronous function.
+     * @param fn - The new async function.
+     */
+    set(fn: () => Promise<T>): void;
+    /**
+     * Prepends a function to be executed before the stored async function.
+     * @param fn - The function to run before the original async function.
+     */
+    prepend(fn: () => Promise<void> | void): void;
+    /**
+     * Appends a function to be executed after the stored async function.
+     * @param fn - The function to run after the original async function.
+     */
+    append(fn: () => Promise<void> | void): void;
 }
-export declare function useAsyncFuncRef<T>(func: () => Promise<T>): AsyncFuncRef<T>;
+/**
+ * Custom hook to create an asynchronous function reference.
+ *
+ * @param fn - The initial asynchronous function.
+ * @returns An object implementing AsyncFuncRef.
+ */
+export declare function useAsyncFuncRef<T>(fn: () => Promise<T>): AsyncFuncRef<T>;
+/**
+ * Interface for a function reference that accepts an argument and returns a result.
+ * Provides methods to call, get, set, and inject code before or after the stored function.
+ */
 export interface ArgFuncRef<TArg, TResult> {
+    /**
+     * Invokes the stored function with the provided argument.
+     * @param arg - The argument to pass to the function.
+     * @returns The result of the function call.
+     */
     call(arg: TArg): TResult;
-    set(func: (arg: TArg) => TResult): void;
+    /**
+     * Retrieves the current function.
+     * @returns The stored function.
+     */
+    get(): (arg: TArg) => TResult;
+    /**
+     * Sets the stored function.
+     * @param fn - The new function.
+     */
+    set(fn: (arg: TArg) => TResult): void;
+    /**
+     * Prepends a function to be executed before the stored function.
+     * @param fn - The function to run before the original function.
+     */
+    prepend(fn: (arg: TArg) => void): void;
+    /**
+     * Appends a function to be executed after the stored function.
+     * @param fn - The function to run after the original function.
+     */
+    append(fn: (arg: TArg) => void): void;
 }
-export declare function useArgFuncRef<TArg, TResult>(func: (arg: TArg) => TResult): ArgFuncRef<TArg, TResult>;
+/**
+ * Custom hook to create an argument-based function reference.
+ *
+ * @param fn - The initial function that accepts an argument and returns a result.
+ * @returns An object implementing ArgFuncRef.
+ */
+export declare function useArgFuncRef<TArg, TResult>(fn: (arg: TArg) => TResult): ArgFuncRef<TArg, TResult>;

package/dist/types/react-viewers/state/cameraState.d.ts

@@ -1,25 +1,23 @@
 /**
  * @module viw-webgl-react
  */
-import { THREE } from '../../index';
+import { SectionBoxRef, THREE } from '../../index';
 import { ActionRef, AsyncFuncRef, StateRef } from '../helpers/reactUtils';
 import { ISignal } from 'ste-signals';
 export interface CameraRef {
     autoCamera: StateRef<boolean>;
     reset: ActionRef;
-    getSelectionBox: AsyncFuncRef<THREE.Box3 | undefined>;
-    getSceneBox: AsyncFuncRef<THREE.Box3 | undefined>;
     frameSelection: AsyncFuncRef<void>;
     frameScene: AsyncFuncRef<void>;
+    getSelectionBox: AsyncFuncRef<THREE.Box3 | undefined>;
+    getSceneBox: AsyncFuncRef<THREE.Box3 | undefined>;
 }
 interface ICameraAdapter {
     onSelectionChanged: ISignal;
     frameCamera: (box: THREE.Box3, duration: number) => void;
     resetCamera: (duration: number) => void;
     getSelectionBox: () => Promise<THREE.Box3 | undefined>;
-    getSceneBox: () => Promise<THREE.Box3>;
-    getSectionBox: () => THREE.Box3;
-    isSectionBoxEnabled: () => boolean;
+    getSceneBox: () => Promise<THREE.Box3 | undefined>;
 }
-export declare function useCamera(adapter: ICameraAdapter): CameraRef;
+export declare function useCamera(adapter: ICameraAdapter, section: SectionBoxRef): CameraRef;
 export {};

package/dist/types/react-viewers/state/sectionBoxState.d.ts

@@ -12,21 +12,23 @@ export interface SectionBoxRef {
     visible: StateRef<boolean>;
     auto: StateRef<boolean>;
     sectionSelection: AsyncFuncRef<void>;
-    sectionReset: AsyncFuncRef<void>;
+    sectionScene: AsyncFuncRef<void>;
     sectionBox: ArgActionRef<THREE.Box3>;
     getBox: () => THREE.Box3;
     showOffsetPanel: StateRef<boolean>;
     topOffset: StateRef<string>;
     sideOffset: StateRef<string>;
     bottomOffset: StateRef<string>;
+    getSelectionBox: AsyncFuncRef<THREE.Box3 | undefined>;
+    getSceneBox: AsyncFuncRef<THREE.Box3>;
 }
 export interface SectionBoxAdapter {
     setClip: (b: boolean) => void;
     setVisible: (visible: boolean) => void;
     getBox: () => THREE.Box3;
     setBox: (box: THREE.Box3) => void;
-    getSelectionBox: () => Promise<THREE.Box3 | undefined>;
-    getRendererBox: () => Promise<THREE.Box3>;
     onSelectionChanged: ISignal;
+    getSelectionBox: () => Promise<THREE.Box3 | undefined>;
+    getSceneBox: () => Promise<THREE.Box3>;
 }
 export declare function useSectionBox(adapter: SectionBoxAdapter): SectionBoxRef;