@realsee/dnalogel 2.0.2-alpha → 2.1.0-alpha.2

package/dist/PanoRulerProPlugin/PanoTagPlugin/utils/index.d.ts

@@ -0,0 +1,12 @@
+export * from '../../CSS3DRenderPlugin/utils';
+export * from './addDebugPoints';
+export * from './noTypecheck';
+export * from './planeNormal';
+export * from './tagPosition';
+export * from './checkRange';
+export * from './actionAfterFiveModelLoad';
+export * from './normalPositionToPositions';
+export * from './debounce';
+export * from './throttle';
+export * from './search';
+export * from './resizeObserver';

package/dist/PanoRulerProPlugin/PanoTagPlugin/utils/noTypecheck.d.ts

@@ -0,0 +1 @@
+export declare const noTypecheck: (x: any) => any;

package/dist/PanoRulerProPlugin/PanoTagPlugin/utils/normalPositionToPositions.d.ts

@@ -0,0 +1,2 @@
+import type { Vector3 } from 'three';
+export declare function normalPositionToPositions(cameraPosition: Vector3, position: Vector3, normal: Vector3): [Vector3, Vector3, Vector3, Vector3];

package/dist/PanoRulerProPlugin/PanoTagPlugin/utils/planeNormal.d.ts

@@ -0,0 +1,4 @@
+import type { Vector3 } from 'three';
+import { AnyPosition } from '.';
+export declare function planeNormal(points: [AnyPosition, AnyPosition, AnyPosition] | [AnyPosition, AnyPosition, AnyPosition, AnyPosition]): Vector3;
+export declare function planeNormal(points: AnyPosition[]): Vector3 | void;

package/dist/PanoRulerProPlugin/PanoTagPlugin/utils/resizeObserver.d.ts

@@ -0,0 +1,4 @@
+export declare function resizeObserver(func: () => any, element?: HTMLElement): {
+    observe: () => void;
+    unobserve: () => void;
+};

package/dist/PanoRulerProPlugin/PanoTagPlugin/utils/search.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 二分查找，查找第一个大于等于给定值的元素
+ * 数组必须有序，存在重复
+ * @param {array} arr 待排序数组
+ * @param {number} target 目标数据
+ */
+export declare function binarySearchFirstBig(getValueByIndex: (index: number) => number, indexRange: [number, number], target: number): number;
+/**
+ * @description: 查找第一个小于前一个数字的值
+ */
+export declare function searchFirstValueSmallThanLastValue(getValueByIndex: (index: number) => number, indexRange: [number, number]): number;

package/dist/PanoRulerProPlugin/PanoTagPlugin/utils/tagPosition.d.ts

@@ -0,0 +1,3 @@
+import type { Vector3 } from 'three';
+import { AnyPosition } from '.';
+export declare function tagPosition(position: AnyPosition | [AnyPosition, AnyPosition, AnyPosition, AnyPosition]): Vector3;

package/dist/PanoRulerProPlugin/PanoTagPlugin/utils/throttle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 创建一个防抖动函数，该函数在高频调用时会每隔 wait 毫秒后调用 func 方法
+ * `throttle` 会在第一次调用时立刻调用一次
+ * @param func - 要防抖动的函数
+ * @param wait - 需要延迟的毫秒数
+ */
+export declare function throttle<T>(func: (...args: T[]) => void, wait?: number): (this: any, ...args: T[]) => void;

package/dist/PanoRulerProPlugin/floorplan/ModelFloorplanPlugin/Controller.d.ts

@@ -1,4 +1,3 @@
-import type { PartialDeep } from 'type-fest';
 import type { BaseOptions } from '../../base/BasePlugin';
 import type { Five } from '@realsee/five';
 import type { ShowState } from '../utils/correctFiveState';
@@ -57,8 +56,8 @@ export declare class Controller extends BasePlugin.Controller<State, EventMap, P
     /** 隐藏户型图 */
     hide: (options?: Partial<HideOptions>) => Promise<void>;
     /** 更改插件 State */
-    setState(state: PartialDeep<State>, options?: BaseOptions): void;
-    changeConfigs(config: Partial<Config>, userAction?: boolean): void;
+    setState(state: Partial<State>, options?: BaseOptions): void;
+    changeConfigs(_config: Partial<Config>, userAction?: boolean): void;
     /** 更新户型图大小 */
     updateSize: () => void;
     protected formatData(serverData: PluginServerData): Promise<PluginData>;

package/dist/PanoRulerProPlugin/floorplan/ModelFloorplanPlugin/typing.d.ts

@@ -21,12 +21,6 @@ export interface Config {
     ruleLabelsEnable: boolean;
     /** 是否要启用户型图分间标签功能，默认为 true */
     roomLabelsEnable: boolean;
-    /** 是否支持房屋标签自适应展示，默认为 true
-     * @description
-     * * 标签边框超过房间边框时，自动隐藏；不超过时自动展示。
-     * * 鼠标 hover 时，自动展示。
-     * */
-    adaptiveRoomLabelVisibleEnable: boolean;
     /** 自定义「雷达」图标 */
     cameraImageUrl: string;
     /** 计算户型图大小时，以模型的哪个高度为依据，默认为 BOUNDING_CENTER
@@ -37,14 +31,12 @@ export interface Config {
     attachedTo: FLOOR_PLAN_ATTACHED_TO;
     /** 分间标签的自定义函数，通过返回自定义 DOM 替换对应分间的标签 */
     getLabelElement: undefined | ((room: FloorplanRoomItem) => Element | null);
-    /** 自定义分间面积文本
-     * @param area 分间原始面积，单位是 mm²
-     */
-    getRoomAreaText: (areaSize: number) => string;
-    /** 自定义标尺距离文本
-     * @param distance 原始标尺距离，单位是 mm
-     */
-    getRuleDistanceText: (distance: number) => string;
+    /** 是否支持房屋标签自适应展示，默认为 true
+     * @description
+     * * 标签边框超过房间边框时，自动隐藏；不超过时自动展示。
+     * * 鼠标 hover 时，自动展示。
+     * */
+    adaptiveRoomLabelVisibleEnable: boolean;
 }
 export interface Parameters extends Partial<Config> {
     selector?: string | Element;
@@ -88,7 +80,7 @@ export interface EventMap extends BasePlugin.EventMap<State, FloorplanData> {
      * 点击户型图的回调
      * @return 当返回 false 时，会阻止默认行为
      */
-    click: () => boolean | undefined;
+    click: () => boolean | void;
 }
 export interface PluginServerData extends BasePlugin.ServerData {
     version: number;

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

@@ -0,0 +1,39 @@
+import * as THREE from 'three';
+import { Subscribe } from '../../Subscribe';
+import type { HelperEventMap } from '../typings';
+import type { BaseHelper } from './BaseHelper';
+import DomEvents from '../utils/threex/domevents';
+export declare abstract class BaseController<T extends BaseHelper = BaseHelper, K extends THREE.Object3D = THREE.Object3D> {
+    hooks: Subscribe<HelperEventMap>;
+    helperObject3D: T;
+    protected originObject3D: K;
+    protected camera: THREE.Camera;
+    protected model: THREE.Object3D;
+    protected scene: THREE.Scene;
+    protected container: HTMLElement;
+    protected domEvents: DomEvents;
+    protected isDragging: boolean;
+    protected needsRender: () => void;
+    protected enabled: boolean;
+    constructor(camera: THREE.Camera, model: THREE.Object3D, originObject3D: K, helperObject3D: T, container: HTMLElement, scene: THREE.Scene, needsRender?: () => void);
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    updateHelperPosition(): void;
+    setHelperPosition(position: THREE.Vector3): void;
+    setHelperMatrix4(matrix4: THREE.Matrix4, origin?: THREE.Vector3): void;
+    setHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    setHelperScaleMatrix4(matrix4: THREE.Matrix4, params?: {
+        origin?: THREE.Vector3;
+        helperOrigin?: THREE.Vector3;
+    }): void;
+    onWantsTapGesture: (raycaster: THREE.Raycaster) => false | void;
+    onWantsGesture(type: 'press' | 'pan' | string, pointers: {
+        x: number;
+        y: number;
+    }[], final: boolean): false | void;
+    protected hoverListener(object3D: THREE.Object3D | undefined | THREE.Group | (THREE.Object3D | undefined | THREE.Group)[], hoverColor?: THREE.Color | string | number, hoverOpacity?: number): () => void;
+    private getIntersectObject;
+}

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

@@ -0,0 +1,89 @@
+import type { Create3DElementReturnType } from '../../../CSS3DRenderPlugin';
+import type * as THREE from 'three';
+import { Mesh, Object3D, Vector3 } from 'three';
+import type { Direction, Direction4 } from '../typings';
+import type { tipsDom } from '../Helper/HTML/tipsDom';
+export declare abstract class BaseHelper<OriginObject3D extends Object3D = Object3D> extends Object3D {
+    protected originObject3D: OriginObject3D;
+    get helperObject(): Object3D;
+    constructor(originObject3D: OriginObject3D);
+    updatePosition(): void;
+    setPosition(position: Vector3): void;
+    updateMatrix4(matrix: THREE.Matrix4, origin?: THREE.Vector3): void;
+    setHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
+        origin?: THREE.Vector3;
+        helperOrigin?: THREE.Vector3;
+    }): void;
+    updateQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    abstract hide(...args: any[]): void;
+    abstract show(...args: any[]): void;
+    abstract dispose(): void;
+}
+export declare abstract class MoveHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+    abstract xArrow?: Object3D & {
+        arrow: Object3D;
+        line?: Object3D;
+        direction: Direction;
+    };
+    abstract yArrow?: Object3D & {
+        arrow: Object3D;
+        line?: Object3D;
+        direction: Direction;
+    };
+    abstract zArrow?: Object3D & {
+        arrow: Object3D;
+        line?: Object3D;
+        direction: Direction;
+    };
+    abstract hide(...directions: Direction[]): void;
+    abstract show(...directions: Direction[]): void;
+}
+export declare abstract class RotateHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+    abstract xyCircle: Mesh & {
+        direction: Direction;
+    };
+    abstract xzCircle: Mesh & {
+        direction: Direction;
+    };
+    abstract yzCircle: Mesh & {
+        direction: Direction;
+    };
+    abstract xRingHelper: Object3D;
+    abstract yRingHelper: Object3D;
+    abstract zRingHelper: Object3D;
+    abstract xAngleHelper: Object3D & {
+        baseAxes: Vector3;
+        direction: Direction;
+    };
+    abstract yAngleHelper: Object3D & {
+        baseAxes: Vector3;
+        direction: Direction;
+    };
+    abstract zAngleHelper: Object3D & {
+        baseAxes: Vector3;
+        direction: Direction;
+    };
+    abstract angleTips?: ReturnType<typeof tipsDom>;
+    abstract hide(): void;
+    abstract show(direction?: Direction): void;
+    abstract updateAngleHelperQuaternion(): void;
+}
+export declare abstract class ScaleHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+}
+declare type NonVoid<T> = T extends void ? never : T;
+export declare abstract class RectangleScaleHelperAbstract<OriginObject3D extends Object3D, PointType extends Object3D | HTMLElement> extends ScaleHelperAbstract<OriginObject3D> {
+    abstract points: PointType extends Object3D ? {
+        point: PointType;
+        direction: Direction4;
+    }[] : {
+        point: PointType;
+        direction: Direction4;
+        position: Vector3;
+    }[];
+    abstract cornerPositions: Vector3[];
+    abstract css3DInstance?: NonVoid<Create3DElementReturnType>;
+    abstract updatePoints(): void;
+    abstract enable(): void;
+    abstract disable(): void;
+}
+export {};

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Constants/color.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+declare const AXES_COLOR: {
+    X: number;
+    Y: number;
+    Z: number;
+};
+declare class AXES_THREE_COLOR {
+    static get X(): THREE.Color;
+    static get Y(): THREE.Color;
+    static get Z(): THREE.Color;
+}
+export { AXES_COLOR, AXES_THREE_COLOR };

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Controller/CSS3DScaleController.d.ts

@@ -0,0 +1,6 @@
+import type { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import { RectangleScaleController } from './RectangleScaleController';
+export declare class CSS3DScaleController extends RectangleScaleController<CSS3DObject, HTMLElement> {
+    constructor(...params: ConstructorParameters<typeof RectangleScaleController<CSS3DObject, HTMLElement>>);
+    private addHTMLEventListener;
+}

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Controller/MoveController.d.ts

@@ -0,0 +1,13 @@
+import { BaseController } from '../Base/BaseController';
+import type { MoveHelperAbstract } from '../Helper';
+export declare class MoveController<T extends MoveHelperAbstract = MoveHelperAbstract> extends BaseController<T> {
+    private startInfo?;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private dragging;
+    private move;
+    private dragEnd;
+}

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Controller/RectangleScaleController.d.ts

@@ -0,0 +1,37 @@
+import { BaseController } from '../Base/BaseController';
+import type { RectangleScaleHelperAbstract } from '../Helper';
+import * as THREE from 'three';
+import type { Direction4 } from '../typings';
+import { Vector3 } from 'three';
+interface StartInfo {
+    startPoint: {
+        position: Vector3;
+        direction: Direction4;
+    };
+    nsMoveIsNegative?: boolean | null;
+    ewMoveIsNegative?: boolean | null;
+    plane: THREE.Plane;
+}
+export declare abstract class RectangleScaleController<OriginObject3D extends THREE.Object3D, PointType extends THREE.Object3D | HTMLElement> extends BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>> {
+    protected startInfo?: StartInfo;
+    constructor(...params: ConstructorParameters<typeof BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>>>);
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    protected getDragPlane(): THREE.Plane;
+    protected dragStart(mousePoint: {
+        x: number;
+        y: number;
+    }, point: {
+        position: THREE.Vector3;
+        direction: Direction4;
+    }): void;
+    protected dragging(point: {
+        x: number;
+        y: number;
+    }): false | void;
+    protected scale(raycaster: THREE.Raycaster): void;
+    protected dragEnd(): void;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { BaseController } from '../Base/BaseController';
+import type { RotateHelperAbstract } from '../Helper';
+export declare class RotateController<T extends RotateHelperAbstract = RotateHelperAbstract> extends BaseController<T> {
+    private startInfo?;
+    private lastRotation?;
+    private rotations;
+    private a;
+    private helperObject3DQuaternion;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private dragging;
+    private rotate;
+    private dragEnd;
+    private getAngleHelper;
+    private setAngleHelperStart;
+    private setAngleHelperLength;
+    private setTipsAngle;
+    private setTipsPosition;
+}

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Helper/HTML/rectangleScaleDom.d.ts

@@ -0,0 +1,11 @@
+import type { Direction4 } from '../../typings';
+interface Square {
+    element: HTMLElement;
+    direction: Direction4;
+}
+export declare function rectangleScaleDom(): {
+    container: HTMLElement;
+    squares: [Square, Square, Square, Square, Square, Square, Square, Square];
+};
+export declare function backgroundDom(): HTMLElement;
+export {};

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Helper/HTML/tipsDom.d.ts

@@ -0,0 +1,6 @@
+export declare function tipsDom(style?: Partial<CSSStyleDeclaration>): {
+    element: HTMLElement;
+    show: () => void;
+    hide: () => void;
+    setLeftTop: (left: string, top: string) => void;
+};

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Helper/HTML/utils/createElement.d.ts

@@ -0,0 +1,2 @@
+export declare function createElement(style?: Partial<CSSStyleDeclaration>, tagName?: string): HTMLElement;
+export declare function setStyle(element: HTMLElement, style?: Partial<CSSStyleDeclaration>): HTMLElement;

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

@@ -0,0 +1,13 @@
+import type { Object3D } from 'three';
+import type { Direction } from '../typings';
+import { MoveHelperAbstract } from '.';
+import { ArrowGroup } from './Objects/ArrowGroup';
+export declare class MoveHelper extends MoveHelperAbstract {
+    xArrow: ArrowGroup;
+    yArrow: ArrowGroup;
+    zArrow: ArrowGroup;
+    constructor(originObject3D: Object3D);
+    hide(...directions: Direction[]): void;
+    show(direction?: Direction): void;
+    dispose(): void;
+}

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Helper/Objects/ArrowGroup.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import type { Direction } from '../../typings';
+import { DirectionGroup, DirectionMesh } from '../../utils';
+interface InstanceParameter {
+    direction: Direction;
+    color?: THREE.Color | string | number;
+}
+export declare class ArrowGroup extends DirectionGroup {
+    line: DirectionMesh<THREE.Geometry, THREE.MeshBasicMaterial>;
+    arrow: DirectionMesh<THREE.ConeGeometry, THREE.MeshBasicMaterial>;
+    private lineHeight;
+    private arrowHeight;
+    constructor(param: InstanceParameter);
+    private formatArrow;
+    private formatLine;
+}
+export {};

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Helper/OutlineHelper.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+export declare class OutlineHelper extends THREE.Group {
+    box: THREE.Mesh<THREE.BufferGeometry, THREE.MeshBasicMaterial>;
+    outline: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    private originObject;
+    private positionAttribute;
+    constructor(obj: THREE.Object3D);
+    private update;
+    private createOutline;
+    private createBox;
+}

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Helper/RectangleScaleHelper.d.ts

@@ -0,0 +1,39 @@
+import * as THREE from 'three';
+import { RectangleScaleHelperAbstract } from '.';
+import type { Create3DElementReturnType } from '../../../CSS3DRenderPlugin';
+import type { Vector3 } from 'three';
+import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import { CSS3DObjectPlus } from '../../../CSS3DRenderPlugin/utils/CSS3DObjectPlus';
+declare type NonVoid<T> = T extends void ? never : T;
+declare type OriginObjectType = CSS3DObject | THREE.Object3D;
+export declare class RectangleScaleHelper<T extends OriginObjectType = OriginObjectType> extends RectangleScaleHelperAbstract<T, HTMLElement> {
+    points: RectangleScaleHelperAbstract<THREE.Object3D, HTMLElement>['points'];
+    cornerPositions: Vector3[];
+    css3DInstance?: NonVoid<Create3DElementReturnType>;
+    get helperObject(): CSS3DObjectPlus<HTMLElement>;
+    private css3DRenderer;
+    private plane?;
+    private camera;
+    private scene;
+    private container;
+    private enabled;
+    constructor(originObject3D: T, container: Element, camera: THREE.Camera, scene: THREE.Scene);
+    updatePosition(): void;
+    setPosition(position: Vector3): void;
+    updateMatrix4(matrix: THREE.Matrix4): void;
+    setHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
+        origin?: Vector3;
+        helperOrigin?: Vector3;
+    }): void;
+    updatePoints(): void;
+    updateQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    private initRectangleScaleHelper;
+    private getCornerPositions;
+    private calculatePointPosition;
+}
+export {};

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

@@ -0,0 +1,54 @@
+import * as THREE from 'three';
+import type { Object3D } from 'three';
+import { RotateHelperAbstract } from '../Base/BaseHelper';
+import type { Color, Direction } from '../typings';
+import { tipsDom } from './HTML/tipsDom';
+export declare class RotateHelper extends RotateHelperAbstract {
+    yzCircle: Circle;
+    xzCircle: Circle;
+    xyCircle: Circle;
+    xRingHelper: AxesDashedRing;
+    yRingHelper: AxesDashedRing;
+    zRingHelper: AxesDashedRing;
+    xAngleHelper: Sector;
+    yAngleHelper: Sector;
+    zAngleHelper: Sector;
+    angleTips?: ReturnType<typeof tipsDom>;
+    private container?;
+    constructor(originObject3D: Object3D, angleTipsParams?: {
+        container: HTMLElement;
+    });
+    updateAngleHelperQuaternion(): void;
+    updateQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    hide(): void;
+    show(direction?: Direction): void;
+    dispose(): void;
+    private filterRingHelper;
+    private filterAngleHelper;
+}
+declare class Circle extends THREE.Mesh {
+    direction: Direction;
+    material: THREE.MeshBasicMaterial;
+    gapAngle: number;
+    geometry: THREE.RingGeometry;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+}
+declare class AxesDashedRing extends THREE.Group {
+    direction: Readonly<Direction>;
+    constructor(options: {
+        direction: Direction;
+    });
+}
+declare class Sector extends THREE.Mesh {
+    direction: Direction;
+    material: THREE.MeshBasicMaterial;
+    baseAxes: THREE.Vector3;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+}
+export {};

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/Helper/index.d.ts

@@ -0,0 +1,5 @@
+export * from '../Base/BaseHelper';
+export * from './MoveHelper';
+export * from './RotateHelper';
+export * from './RectangleScaleHelper';
+export * from './OutlineHelper';

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

@@ -0,0 +1,73 @@
+import type { OutlineHelper } from './Helper';
+import type { EventMap, State } from './typings';
+import type { MoveController } from './Controller/MoveController';
+import type { RotateController } from './Controller/RotateController';
+import type { BaseController } from './Base/BaseController';
+import { Subscribe } from '../Subscribe';
+interface Controllers {
+    moveController?: MoveController;
+    rotateController?: RotateController;
+    scaleController?: BaseController;
+}
+interface Helpers {
+    outlineHelper?: OutlineHelper;
+}
+export declare class Object3DHelper {
+    controllers: Controllers;
+    state: State;
+    hooks: Subscribe<EventMap>;
+    private helpers;
+    private eventListener;
+    constructor(controllers?: Controllers, helpers?: Helpers);
+    /**
+     * @description Show guide line
+     */
+    show(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Hide guide line
+     */
+    hide(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Enable
+     */
+    enable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Disable
+     */
+    disable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Dispose
+     */
+    dispose(): void;
+    setState(state: Partial<State>, options?: {
+        userAction?: boolean;
+    } & Record<string, any>): void;
+    addControllers(controllers: Partial<{
+        [K in keyof Controllers]: Controllers[K];
+    }>): void;
+    addHelpers(helpers: Partial<{
+        [K in keyof Helpers]: Helpers[K];
+    }>): void;
+    getCurrentState(): State;
+    private addEventListener;
+    private handleEnd;
+    private handleStart;
+    private setOtherHelpersVisible;
+    private handlePositionUpdate;
+    private handleScaleUpdate;
+    private handleRotateUpdate;
+    private handleEnable;
+    private handleVisible;
+    private everyControllerDo;
+    private handleDispose;
+    private actionIfStateIsEnabled;
+}
+export {};

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/typings/Direction.d.ts

@@ -0,0 +1,2 @@
+export declare type Direction = 'x' | 'y' | 'z';
+export declare type Direction4 = 'nesw' | 'nwse' | 'ns' | 'ew';

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

@@ -0,0 +1,46 @@
+import type * as THREE from 'three';
+export declare type HelperEventMap = {
+    moveStart: () => void;
+    rotateStart: () => void;
+    scaleStart: () => void;
+    positionUpdate: (position: {
+        matrix4?: THREE.Matrix4;
+        position?: THREE.Vector3;
+    } | undefined) => void;
+    rotateUpdate: (rotate: {
+        quaternion?: THREE.Quaternion;
+        origin: THREE.Vector3;
+    } | undefined) => void;
+    scaleUpdate: (scale: {
+        matrix4?: THREE.Matrix4;
+        origin?: THREE.Vector3;
+        helperOrigin: THREE.Vector3;
+    } | undefined) => void;
+    moveEnd: () => void;
+    rotateEnd: () => void;
+    scaleEnd: () => void;
+};
+export interface State {
+    enabled: boolean;
+    visible: boolean;
+    disposed: boolean;
+}
+export declare type EventMap = {
+    show: (options?: {
+        userAction?: boolean;
+    }) => void;
+    hide: (options?: {
+        userAction?: boolean;
+    }) => void;
+    enable: (options?: {
+        userAction?: boolean;
+    }) => void;
+    disable: (options?: {
+        userAction?: boolean;
+    }) => void;
+    dispose: () => void;
+    stateChange: (params: {
+        state: State;
+        prevState?: State;
+    }) => void;
+};

package/dist/PanoRulerProPlugin/shared-utils/Object3DHelper/typings/Scissor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 显示区域裁剪参数
+ * @description
+ * 可通过初始化，或者 setScissor 方式设置
+ * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
+ * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
+ */
+export interface Scissor {
+    /** 距离左侧 */
+    left: number;
+    /** 距离下侧 */
+    bottom: number;
+    /** 宽度 */
+    width: number;
+    /** 高度 */
+    height: number;
+}