@realsee/dnalogel 3.20.6 → 3.21.0

package/dist/shared-utils/Object3DHelper/Base/BaseController.d.ts

@@ -1,11 +1,18 @@
 import * as THREE from 'three';
 import { Subscribe } from '../../Subscribe';
-import type { HelperEventMap, HelperOffset, InternalHelperEventMap } from '../typings';
+import type { HelperEventMap, HelperOffset, InternalHelperEventMap, ScaleCallback } from '../typings';
 import type { BaseHelper } from './BaseHelper';
 import DomEvents from '../../threex/domevents';
 export declare let originOpacity: {
     opacity: number;
 } | null;
+type Config = {
+    offset?: HelperOffset;
+    yAxis?: THREE.Vector3;
+    xAxis?: THREE.Vector3;
+    zAxis?: THREE.Vector3;
+    scaleCallback?: ScaleCallback;
+};
 export declare abstract class BaseController<T extends BaseHelper = BaseHelper, K extends THREE.Object3D = THREE.Object3D> {
     originObject3D: K;
     hooks: Subscribe<HelperEventMap>;
@@ -22,7 +29,7 @@ export declare abstract class BaseController<T extends BaseHelper = BaseHelper,
     protected enabled: boolean;
     protected name: string;
     protected boundingBox?: THREE.Box3;
-    private offset?;
+    protected config?: Config;
     private onRender;
     constructor(params: {
         camera: THREE.Camera;
@@ -34,9 +41,7 @@ export declare abstract class BaseController<T extends BaseHelper = BaseHelper,
         onRender?: () => void;
         sharedHooks?: Subscribe<HelperEventMap>;
         sharedInternalHooks?: Subscribe<InternalHelperEventMap>;
-    }, config?: {
-        offset?: HelperOffset;
-    });
+    }, config?: Config);
     initialHelperPosition(): void;
     initialHelperQuaternion(): void;
     enable(): void;
@@ -62,6 +67,7 @@ export declare abstract class BaseController<T extends BaseHelper = BaseHelper,
      */
     applyHelperScaleMatrix4(matrix: THREE.Matrix4, origin?: THREE.Vector3): void;
     onWantsTapGesture: (raycaster: THREE.Raycaster) => false | void;
+    onWantsUpdateCameraDistance: () => void;
     onWantsGesture(type: 'press' | 'pan' | string, pointers: {
         x: number;
         y: number;
@@ -99,5 +105,7 @@ export declare abstract class BaseController<T extends BaseHelper = BaseHelper,
     protected updateOffsetByScale(scale: THREE.Vector3): void;
     protected hoverListener(object3D: THREE.Object3D | undefined | THREE.Group | (THREE.Object3D | undefined | THREE.Group)[], hoverColor?: THREE.Color | string | number, hoverOpacity?: number): () => void;
     private getIntersectObject;
+    private getBox;
     private calculateOffset;
 }
+export {};

package/dist/shared-utils/Object3DHelper/Base/BaseHelper.d.ts

@@ -2,24 +2,32 @@ import type { Create3DElementReturnType } from '../../../CSS3DRenderPlugin';
 import type * as THREE from 'three';
 import type { Group, Mesh, Object3D } from 'three';
 import { Vector3 } from 'three';
-import type { Direction, Direction4 } from '../typings';
+import type { Direction, Direction4, PositionFrom, ScalePosition } from '../typings';
 import type { tipsDom } from '../Helper/HTML/tipsDom';
 import { IObject3D } from '../../three/IObject3D';
 type NonVoid<T> = T extends void ? never : T;
+export interface BaseHelperConfig {
+    onRender?: () => any;
+    /**
+     * @description: helper 初始位置来源
+     * @default 'objectPosition'
+     */
+    positionFrom?: PositionFrom;
+}
 export declare abstract class BaseHelper<OriginObject3D extends Object3D = Object3D> extends IObject3D {
     protected originObject3D: OriginObject3D;
     protected onRender: () => any;
+    private positionFrom;
     get helperObject(): Object3D;
-    constructor(originObject3D: OriginObject3D, config?: {
-        onRender?: () => any;
-    });
+    constructor(originObject3D: OriginObject3D, config?: BaseHelperConfig);
     render(): void;
     enable(): void;
     disable(): void;
     show(): void;
     hide(): void;
     raycasterIntersectObject(raycaster: THREE.Raycaster, intersection?: THREE.Intersection[]): THREE.Intersection[];
-    initialPosition(): void;
+    initialPosition(offset?: THREE.Vector3): void;
+    setScaleByCamera(camera: THREE.PerspectiveCamera): void;
     initQuaternion(): void;
     applyHelperScaleMatrix4(matrix: THREE.Matrix4, origin?: Vector3): void;
     setHelperQuaternion(quaternion: THREE.Quaternion, origin?: Vector3): void;
@@ -62,8 +70,11 @@ export declare abstract class RotateHelperAbstract<OriginObject3D extends Object
     abstract showDraggingHelper(directions: Direction[]): void;
 }
 export declare abstract class ScaleHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+    abstract scaleMeshes: Array<Mesh & {
+        scalePosition: ScalePosition;
+    }>;
 }
-export declare abstract class RectangleScaleHelperAbstract<OriginObject3D extends Object3D, PointType extends Object3D | HTMLElement> extends ScaleHelperAbstract<OriginObject3D> {
+export declare abstract class RectangleScaleHelperAbstract<OriginObject3D extends Object3D, PointType extends Object3D | HTMLElement> extends BaseHelper<OriginObject3D> {
     abstract points: PointType extends Object3D ? {
         point: PointType;
         direction: Direction4;

package/dist/shared-utils/Object3DHelper/Controller/RotateController.d.ts

@@ -7,7 +7,6 @@ export declare class RotateController<T extends RotateHelperAbstract = RotateHel
     private startInfo?;
     private removeListener;
     constructor(...params: ConstructorParameters<typeof BaseController<T>>);
-    initialHelperQuaternion(): void;
     setRotateAngle(angle: {
         x?: number;
         y?: number;

package/dist/shared-utils/Object3DHelper/Controller/ScaleController.d.ts

@@ -1,12 +1,19 @@
 import { BaseController } from '../Base/BaseController';
 import type { ScaleHelperAbstract } from '../Helper';
 import * as THREE from 'three';
-export declare class ScaleController<OriginObject3D extends THREE.Object3D = THREE.Object3D> extends BaseController<ScaleHelperAbstract<OriginObject3D>> {
+export declare class ScaleController<T extends ScaleHelperAbstract = ScaleHelperAbstract> extends BaseController<T> {
     protected name: string;
-    constructor(...params: ConstructorParameters<typeof BaseController<ScaleHelperAbstract<OriginObject3D>>>);
-    setScale(scale: number | {
-        x?: number;
-        y?: number;
-        z?: number;
-    }): void;
+    private startInfo?;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    initialHelperQuaternion(): void;
+    initialHelperPosition(): void;
+    dragStart: (params: {
+        intersect: THREE.Intersection;
+    }) => void;
+    dragging: (point: {
+        x: number;
+        y: number;
+    }) => false | void;
+    scale: (raycaster: THREE.Raycaster) => void;
+    dragEnd: () => void;
 }

package/dist/shared-utils/Object3DHelper/Helper/MoveHelper.d.ts

@@ -1,7 +1,8 @@
 import type { Object3D } from 'three';
 import type { Direction } from '../typings';
-import { MoveHelperAbstract } from '.';
+import { MoveHelperAbstract, type BaseHelperConfig } from '.';
 import { ArrowGroup } from './Objects/ArrowGroup';
+import type * as THREE from 'three';
 export declare class MoveHelper extends MoveHelperAbstract {
     xArrow?: ArrowGroup;
     yArrow?: ArrowGroup;
@@ -10,8 +11,9 @@ export declare class MoveHelper extends MoveHelperAbstract {
         xArrowEnable?: boolean;
         yArrowEnable?: boolean;
         zArrowEnable?: boolean;
-    });
+    } & BaseHelperConfig);
     show(): void;
+    setScaleByCamera(camera: THREE.PerspectiveCamera): void;
     showDraggingHelper(directions: Direction[]): void;
     dispose(): void;
 }

package/dist/shared-utils/Object3DHelper/Helper/RotateHelper.d.ts

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import type { Object3D } from 'three';
-import { RotateHelperAbstract } from '../Base/BaseHelper';
+import { RotateHelperAbstract, type BaseHelperConfig } from '../Base/BaseHelper';
 import type { Color, Direction } from '../typings';
 import { tipsDom } from './HTML/tipsDom';
 export declare class RotateHelper extends RotateHelperAbstract {
@@ -16,9 +16,10 @@ export declare class RotateHelper extends RotateHelperAbstract {
         xzCircleEnable?: boolean;
         xyCircleEnable?: boolean;
         angleTipsEnable?: boolean;
-    });
+    } & BaseHelperConfig);
     hide(): void;
     show(): void;
+    setScaleByCamera(camera: THREE.PerspectiveCamera): void;
     showDraggingHelper(directions: Direction[]): void;
     dispose(): void;
 }

package/dist/shared-utils/Object3DHelper/Helper/ScaleHelper.d.ts

@@ -1,5 +1,14 @@
-import type * as THREE from 'three';
-import { ScaleHelperAbstract } from '../Base/BaseHelper';
+import * as THREE from 'three';
+import { ScaleHelperAbstract, type BaseHelperConfig } from '../Base/BaseHelper';
+import type { ScalePosition } from '../typings';
 export declare class ScaleHelper<T extends THREE.Object3D = THREE.Object3D> extends ScaleHelperAbstract<T> {
-    constructor(originObject3D: T);
+    scaleMeshes: Array<THREE.Mesh & {
+        scalePosition: ScalePosition;
+    }>;
+    private positions;
+    constructor(originObject3D: T, config?: {
+        positions?: Array<ScalePosition> | (() => Array<ScalePosition>);
+    } & BaseHelperConfig);
+    initialPosition(offset?: THREE.Vector3): void;
+    setScaleByCamera(camera: THREE.PerspectiveCamera): void;
 }

package/dist/shared-utils/Object3DHelper/typings/Hooks.d.ts

@@ -16,6 +16,7 @@ export type HelperEventMap = {
     moveByMouseDisable: () => void;
 };
 export type InternalHelperEventMap = {
+    initialHelperPosition: () => void;
     setObjectPosition: (position: THREE.Vector3) => void;
     setObjectRotate: (quaternion: THREE.Quaternion, origin?: THREE.Vector3) => void;
     setObjectScale: (scale: THREE.Vector3) => void;

package/dist/shared-utils/Object3DHelper/typings/index.d.ts

@@ -19,9 +19,20 @@ export interface HelperOffset {
 }
 export type Color = THREE.Color | string | number;
 export type ClassFunctionParameters<C extends new (...params: any[]) => any, F extends keyof InstanceType<C>> = Parameters<InstanceType<C>[F]>;
+export type PositionFrom = 'objectPosition' | 'boundingBox' | THREE.Vector3 | (() => THREE.Vector3);
 export interface ObjectHelperControllers {
     moveController?: MoveController;
     rotateController?: RotateController;
     scaleController?: ScaleController;
     boundingBoxController?: BoundingBoxController;
 }
+export type ScaleCallback = (params: {
+    ratio: number;
+    intersectPoint: THREE.Vector3;
+    scalePosition: ScalePosition;
+}) => any;
+export type ScalePosition = {
+    id?: string;
+    handlePosition: THREE.Vector3;
+    basePosition: THREE.Vector3;
+};

package/dist/shared-utils/Object3DHelper/utils/calculateScaleByCamera.d.ts

@@ -0,0 +1,2 @@
+import type * as THREE from 'three';
+export default function calculateScaleByCamera(camera: THREE.PerspectiveCamera, position: THREE.Vector3): number;

package/dist/shared-utils/createLine/index.d.ts

@@ -1,3 +1,3 @@
-import { Line } from '@realsee/five/line';
 import { Vector3 } from 'three';
-export default function createLine(point1: Vector3, point2: Vector3, color?: Vector3, dashed?: boolean): Line;
+import { FiveLine } from '../five/FiveLine';
+export default function createLine(point1: Vector3, point2: Vector3, color?: Vector3, dashed?: boolean): FiveLine;

package/dist/shared-utils/five/FiveDomEvents.d.ts

@@ -8,44 +8,76 @@
  */
 import type { Five } from '@realsee/five';
 import * as THREE from 'three';
-interface EventMap {
+export interface FiveDomEventMap {
     /**
      * @description 点击事件
      * @return {PreventFiveEvent} 返回 false 可以不阻止 five 的 tap 事件; default: true
      */
-    click: (event: CallbackEvent) => PreventFiveEvent | void;
+    click: (event: FiveDomEvent) => PreventFiveEvent | void;
+    /**
+     * @description 双击事件
+     */
+    dblclick: (event: FiveDomEvent) => void;
+    /**
+     * @description 鼠标按下事件
+     */
+    mousedown: (event: FiveDomEvent) => void;
+    /**
+     * @description 鼠标抬起事件
+     */
+    mouseup: (event: FiveDomEvent) => void;
     /**
      * @description 鼠标移入事件
      */
-    hover: (event: CallbackEvent) => void;
+    hover: (event: FiveDomEvent) => void;
     /**
      * @description 鼠标移出事件
      */
-    unHover: (event: CallbackEvent) => void;
+    unHover: (event: FiveDomEvent) => void;
+    /**
+     * @description: 拖动开始
+     */
+    dragstart: (event: FiveDomEvent) => void;
+    /**
+     * @description: 拖动中
+     */
+    drag: (event: FiveDomEvent) => void;
+    /**
+     * @description: 拖动结束
+     */
+    dragend: (event: FiveDomEvent) => void;
 }
-type EventName = keyof EventMap;
+type EventName = keyof FiveDomEventMap;
 type PreventFiveEvent = boolean;
 interface EventHandlerConfig {
     /**
-     * @default true
+     * @default false
      */
-    checkVisible?: boolean;
+    noEmitWhenHide?: boolean;
 }
-interface CallbackEvent {
+export interface FiveDomEvent {
     type: EventName;
     target: THREE.Object3D;
     origDomEvent?: Event;
-    intersect: THREE.Raycaster;
+    raycaster: THREE.Raycaster;
+    intersects?: THREE.Intersection[];
     stopPropagation: () => void;
 }
 type Object3DWithEvent = THREE.Object3D & {
     _domEvent?: {
-        [key in `${EventName}Handler`]?: Array<[EventMap[EventName], EventHandlerConfig]>;
+        [key in `${EventName}Handler`]?: Array<[FiveDomEventMap[EventName], EventHandlerConfig]>;
     };
     _hovered?: boolean;
+    _dragging?: boolean;
+    draggable?: boolean;
 };
 export declare class FiveDomEvents {
     private five;
+    /**
+     * @description: 拖动中
+     */
+    private dragging;
+    private get haveDragEventObject();
     private boundObject;
     constructor(five: Five);
     /**
@@ -53,7 +85,7 @@ export declare class FiveDomEvents {
      * @note: 注意：目前需要触发物体的 added 事件和 removed 事件才会生效
      * @todo: added 和 removed 还是不太智能
      */
-    addAutoBindEventListener<T extends EventName>(object: Object3DWithEvent, event: T, callback: EventMap[T], config?: EventHandlerConfig): () => void;
+    addAutoBindEventListener<T extends EventName = EventName>(object: Object3DWithEvent, event: T, callback: FiveDomEventMap[T], config?: EventHandlerConfig): () => void;
     /**
      * @description: add event listener
      * @param params.object: object
@@ -61,11 +93,16 @@ export declare class FiveDomEvents {
      * @param params.callback: 返回 false 可以不阻止 five 的 tap 事件; default: true
      * @return {void}
      */
-    addEventListener<T extends EventName>(object: Object3DWithEvent, event: T, callback: EventMap[T], config?: EventHandlerConfig): void;
-    removeEventListener(object: Object3DWithEvent, event: EventName, callback: (e: CallbackEvent) => any, ...args: any[]): void;
+    addEventListener<T extends EventName = EventName>(object: Object3DWithEvent, event: T, callback: FiveDomEventMap[T], config?: EventHandlerConfig): void;
+    removeEventListener(object: Object3DWithEvent, event: EventName, callback: (e: FiveDomEvent) => any, ...args: any[]): void;
     dispose(): void;
     private getRaycaster;
     private handleWantsGesture;
+    private handleDomEvent;
+    private handleMouseEvent;
+    private handleMousedown;
+    private handleMouseup;
+    private handleMousemove;
     private onDomEvent;
     private objectIsBound;
     private notify;

package/dist/shared-utils/five/FiveLine.d.ts

@@ -0,0 +1,8 @@
+import { Line } from '@realsee/five/line';
+export declare class FiveLine extends Line {
+    constructor(...args: ConstructorParameters<typeof Line>);
+    toJSON(): {
+        type: string;
+        points: any;
+    };
+}

package/dist/shared-utils/five/getPosition.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+import type { Five } from '@realsee/five';
+interface IIntersection extends THREE.Intersection {
+    raycaster: THREE.Raycaster;
+    isVirtual: boolean;
+}
+export declare function getIntersectByNdcPosition(five: Five, position: {
+    x: number;
+    y: number;
+}): IIntersection;
+export declare function getIntersectByRaycaster(five: Five, raycaster: THREE.Raycaster): IIntersection;
+export declare function getVirtualIntersectByRaycaster(raycaster: THREE.Raycaster): IIntersection;
+export declare function getRealIntersectByRaycaster(five: Five, raycaster: THREE.Raycaster): IIntersection;
+export {};

package/dist/shared-utils/five/getRaycasterByNdcPosition.d.ts

@@ -0,0 +1,6 @@
+import type { Five } from '@realsee/five';
+import * as THREE from 'three';
+export declare function getRaycasterByNdcPosition(five: Five, position: {
+    x: number;
+    y: number;
+}): THREE.Raycaster;

package/dist/shared-utils/positionToVector3.d.ts

@@ -4,6 +4,7 @@ export type AnyPosition = Vector3 | number[] | {
     y: number;
     z: number;
 };
+export type AnyPositions = Array<AnyPosition>;
 export declare const positionToVector3: ({ x, y, z }: {
     x: number;
     y: number;

package/dist/shared-utils/three/IObject3D.d.ts

@@ -1,7 +1,11 @@
 import { Object3D } from 'three';
 export declare class IObject3D extends Object3D {
+    name: string;
+    needsRender: boolean;
     constructor();
+    removeChildren(): this;
     add(...objects: Object3D[]): this;
+    addIfNotExists(...objects: Object3D[]): this;
     remove(...objects: Object3D[]): this;
     removeFromParent(): this;
 }

package/dist/shared-utils/three/Magnifier.d.ts

@@ -2,23 +2,25 @@ import type { Five, SubscribeEventMap } from '@realsee/five';
 import Hammer from 'hammerjs';
 import * as THREE from 'three';
 import { Subscribe } from '@realsee/five';
+interface MagnifierConfig {
+    /** 允许拖动放大镜 */
+    dragEnabled: boolean;
+    /** renderWithPoint 时，是否应该自动更新放大镜的位置 */
+    autoFixPCPosition: boolean;
+    /** 放大镜初始位置应该设置在容器的哪个位置 */
+    initialPosition: {
+        left: string;
+        top: string;
+    };
+}
 interface MagnifierEvent extends SubscribeEventMap {
     wantsPanGesture: (event: (typeof Hammer)['Input']) => boolean;
 }
 /** 放大镜配置参数 */
-export interface MagnifierParameter {
+export interface MagnifierParameter extends Partial<MagnifierConfig> {
     width?: number;
     height?: number;
     scale?: number;
-    /** 允许拖动放大镜 */
-    dragEnabled?: boolean;
-    /** renderWithPoint 时，是否应该自动更新放大镜的位置 */
-    autoFixPCPosition?: boolean;
-    /** 放大镜初始位置应该设置在容器的哪个位置 */
-    initialPosition?: {
-        left: string;
-        top: string;
-    };
 }
 export declare class Magnifier {
     width: number;
@@ -26,33 +28,45 @@ export declare class Magnifier {
     containerDom?: Element;
     hooks: Subscribe<MagnifierEvent>;
     canvas: HTMLCanvasElement;
+    config: MagnifierConfig;
+    state: {
+        enabled: boolean;
+    };
     private five;
     private scale;
-    private config;
     private offset;
     private context;
     private renderCenter;
     private hammer?;
-    private state;
+    private offsetRange?;
+    private isPanning;
     constructor(five: Five, options: MagnifierParameter);
-    getCurrentState(): {
-        enabled: boolean;
-    };
-    dispose(): void;
-    show(): this;
-    hide(): this;
     enable(): this;
     disable(): this;
+    dispose(): void;
     /** 把放大镜放到某一个容器中 */
     appendTo(element: Element): this;
     /** 清除放大镜渲染内容 */
     clear(): this;
     /** 放大传入点位周围的内容 */
     renderWithPoint(point: THREE.Vector3): void;
+    /** 放大传入点位周围的内容 */
+    renderWithScreenPoint(point: {
+        x: number;
+        y: number;
+    }): void;
+    resetOffset(): void;
+    protected getRenderCenter(): THREE.Vector3 | {
+        x: number;
+        y: number;
+    };
+    private _appendTo;
     private autoFixPCPosition;
     private render;
     private initStyle;
+    private getPanOffset;
+    private onPanstart;
     private onPan;
-    private onPanEnd;
+    private onPanend;
 }
 export {};

package/dist/shared-utils/three/PointSelector.d.ts

@@ -1,7 +1,7 @@
-import type { Five, SubscribeEventMap } from '@realsee/five';
-import { Subscribe } from '@realsee/five';
+import type { Five } from '@realsee/five';
 import { PointSelectorHelper, type PointIntersection } from './PointSelectorHelper';
-import { Vector3 } from 'three';
+import type { Vector3 } from 'three';
+import { Subscribe } from '../Subscribe';
 interface Config {
     /**
      * @description: 选点的两种模式, 'fixed' 为固定选点为屏幕中心点，拖动five画布来更新点，'cursor' 为跟随鼠标移动来更新点, 'auto' 则根据设备类型自动选择
@@ -10,7 +10,7 @@ interface Config {
     mode: 'fixed' | 'cursor' | 'auto';
     pointSelectorHelperParams: ConstructorParameters<typeof PointSelectorHelper>[1];
 }
-interface EventMap extends SubscribeEventMap {
+type EventMap = {
     /**
      * @description: 与模型交点更新时触发，移出监听范围时为null
      * @param isAdhered 是否为吸附的点
@@ -20,23 +20,35 @@ interface EventMap extends SubscribeEventMap {
      * @description: 试图打点，返回false则不打点
      */
     wantsSelect: (intersection: PointIntersection) => boolean | void;
+    /**
+     * @description: 打点成功
+     */
     select: (intersection: PointIntersection) => void;
-}
+    /**
+     * @description: 功能开启
+     */
+    enable: () => void;
+    /**
+     * @description: 功能关闭
+     */
+    disable: () => void;
+};
 /**
  * @description: 在屏幕上选点
  */
-export declare class PointSelector {
-    hook: Subscribe<EventMap>;
+export declare class PointSelector extends Subscribe<EventMap> {
     get position(): PointIntersection;
     /**
      * @description: 不在 five canvas 上时为 true
      */
     outOfFive: boolean;
+    enabled: boolean;
+    pointSelectorHelper: PointSelectorHelper;
+    /** @deprecated directly use `pointSelector.on/off` instead */
+    hook: this;
     private five;
     private hammer?;
     private mode;
-    private pointSelectorHelper;
-    private enabled;
     /** 长按屏幕的动作触发后为true，手指抬起后为false */
     private pressDown;
     /** 一组吸附的点，光标靠近这些点时，会将helper以及放大镜的位置设置为这些点 */
@@ -44,11 +56,13 @@ export declare class PointSelector {
     /** 吸附点的半径 */
     private adherePointsRadius;
     private lastFiveHelperVisible?;
+    private mousePosition;
+    private get mouseNdcPosition();
     constructor(five: Five, config?: Partial<Config>);
     enable(): void;
     disable(): void;
     dispose(): void;
-    setAdherePoints(points: Vector3[] | Vector3 | null, radius?: number): void;
+    setAdherePoints(points: Vector3[] | ((intersection: PointIntersection) => Vector3[]) | null, radius?: number): void;
     /**
      * @description: 主动触发一次选点
      * @return: select 是否成功
@@ -76,7 +90,6 @@ export declare class PointSelector {
      * @description: 手指抬起后，重置pressDown状态
      */
     private onPanEnd;
-    private intersectionOnModelUpdate;
     private updateByMousePosition;
     /**
      * @description: 根据鼠标位置更新helper位置
@@ -86,6 +99,7 @@ export declare class PointSelector {
      * @description: 更新 pointSelectorHelper 的焦点位置
      */
     private updatePointSelectorHelperIntersect;
+    private mousePositionToNdcPosition;
     private onFiveWantsPanGesture;
     private renderScreenCenter;
     private emitIntersectionUpdate;

package/dist/shared-utils/three/PointSelectorHelper.d.ts

@@ -1,3 +1,4 @@
+import * as THREE from 'three';
 import type { Five } from '@realsee/five';
 import { Subscribe } from '@realsee/five';
 import { Magnifier, PointHelper, PointDomHelper } from '.';
@@ -18,6 +19,7 @@ type EventMap = {
 };
 export interface PointIntersection extends Intersection {
     isVirtual?: boolean;
+    raycaster?: THREE.Raycaster;
 }
 export declare class PointSelectorHelper {
     five: Five;

package/{libs/PanoMeasurePlugin/utils → dist/shared-utils/three}/geometryUtil.d.ts

@@ -4,4 +4,4 @@ export declare function getGeometryArea(geometry: THREE.BufferGeometry): number;
 export declare function getGeometryInfo(geometry: THREE.BufferGeometry): {
     center: Vector3;
     area: number;
-} | void;
+} | undefined;

package/dist/shared-utils/three/getIntersect.d.ts

@@ -1,5 +1,19 @@
-import type { Five, Intersection } from '@realsee/five';
+import * as THREE from 'three';
+import type { Five } from '@realsee/five';
 export declare function getIntersectFromRelativePosition(five: Five, position: {
     x: number;
     y: number;
-}): Intersection;
+}): {
+    raycaster: THREE.Raycaster;
+    isVirtual: boolean;
+    floor: number;
+    distance: number;
+    distanceToRay?: number;
+    point: THREE.Vector3;
+    index?: number;
+    face?: THREE.Face3;
+    faceIndex?: number;
+    object: THREE.Object3D;
+    uv?: THREE.Vector2;
+    instanceId?: number;
+};

package/dist/shared-utils/three/getNormal.d.ts

@@ -1,2 +1,2 @@
-import { Vector3 } from 'three';
+import type { Vector3 } from 'three';
 export default function getNormal(points: Vector3[], length?: number): Vector3;

package/dist/shared-utils/three/recurveFindObject.d.ts

@@ -0,0 +1,2 @@
+import type * as THREE from 'three';
+export default function recurveFindObject(object: THREE.Object3D, end: (obj: THREE.Object3D & {}) => boolean): any;

package/dist/shared-utils/three/vector3ToArray.d.ts

@@ -0,0 +1,3 @@
+import type * as THREE from 'three';
+import type { ReplaceDeep } from '../../Sculpt/typings/utils.type';
+export default function vector3ToArray<V extends THREE.Vector3 | THREE.Vector3[]>(vector3: V): ReplaceDeep<V, THREE.Vector3, [number, number, number]>;