@realsee/dnalogel 2.1.2-alpha.9 → 2.2.0

package/dist/floorplan/typings/index.d.ts

@@ -0,0 +1,117 @@
+import type { FloorplanRoomItem } from './floorplanData';
+import type { FLOOR_PLAN_ATTACHED_TO } from '../constant';
+import type { FloorplanData } from '../typings/floorplanData';
+import type * as BasePlugin from '../../base/BasePluginWithData';
+import type { FloorplanServerData } from '../typings/floorplanServerData';
+export interface State extends BasePlugin.State {
+    visible: boolean;
+    config: Config;
+}
+export interface Config {
+    /** 指北针的显示文案，默认为 '北' */
+    northDesc: string;
+    /** 户型图展示时，模型的透明度，默认为 1 */
+    modelOpacity: number;
+    /** 鼠标放置在分间上时，是否要自动高亮分间，默认为 true */
+    hoverEnable: boolean;
+    /** 是否要启用指北针功能，默认为 true */
+    compassEnable: boolean;
+    /** Five 切换到 Topview Mode 时，是否自动展示户型图，默认为 true */
+    autoShowEnable: boolean;
+    /** 是否要启用户型图分间标尺功能，默认为 true */
+    ruleLabelsEnable: boolean;
+    /** 是否要启用户型图分间标签功能，默认为 true */
+    roomLabelsEnable: boolean;
+    /** 是否支持房屋标签自适应展示，默认为 true
+     * @description
+     * * 标签边框超过房间边框时，自动隐藏；不超过时自动展示。
+     * * 鼠标 hover 时，自动展示。
+     * */
+    adaptiveRoomLabelVisibleEnable: boolean;
+    /** 自定义「雷达」图标 */
+    cameraImageUrl: string;
+    /** 计算户型图大小时，以模型的哪个高度为依据，默认为 BOUNDING_CENTER
+     * - FLOOR_PLAN_ATTACHED_TO.FLOOR: 户型图大小与模型的地板进行贴合
+     * - FLOOR_PLAN_ATTACHED_TO.CEILING: 户型图大小与模型的天花板进行贴合
+     * - FLOOR_PLAN_ATTACHED_TO.BOUNDING_CENTER: 户型图大小与模型的中心进行贴合
+     */
+    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;
+}
+/** 插件初始化参数 */
+export interface Parameters extends Partial<Config> {
+    selector?: string | Element;
+    scale?: number;
+}
+export interface PluginServerData extends BasePlugin.ServerData {
+    version: number;
+    data: FloorplanServerData;
+}
+export interface ViewEvent {
+    /** 是否是用户滑动模型导致的户型图自动展示/消失 */
+    auto: boolean;
+    /** 是否是用户操作 */
+    userAction: boolean;
+}
+export interface EventMap extends BasePlugin.EventMap<State, FloorplanData> {
+    /**
+     * 展示结束的回调
+     * @param event.auto 是否是自动操作
+     * @param event.userAction 是否是用户操作
+     */
+    showAnimationEnded: (event: ViewEvent) => void;
+    /** visible 从 false 到 true 的回调
+     * @param event.userAction 是否是用户操作
+     */
+    show: (event: ViewEvent) => void;
+    /** visible 从 true 到 false 的回调
+     * @param event.auto 是否是自动操作
+     * @param event.userAction 是否是用户操作
+     */
+    hide: (event: ViewEvent) => void;
+    /** enabled 从 false 到 true 的回调
+     * @param event.userAction 是否是用户操作
+     */
+    enable: (event: {
+        userAction: boolean;
+    }) => void;
+    /** enabled 从 true 到 false 的回调
+     * @param event.userAction 是否是用户操作
+     */
+    disable: (event: {
+        userAction: boolean;
+    }) => void;
+    /**
+     * 点击户型图的回调
+     * @return 当返回 false 时，会阻止默认行为
+     */
+    click: () => boolean | undefined;
+}
+export interface ShowOptions {
+    /** 展示户型图时，希望到达的楼层数 */
+    floorIndex: number;
+    /** 是否自动展示 */
+    isAutoShow: boolean;
+    /** 展示户型图时，模型透明度 */
+    modelOpacity: number;
+    /** 是否需要 opacity 动画 */
+    immediately: boolean;
+    /** 是否是用户操作 */
+    userAction: boolean;
+}
+export interface HideOptions {
+    /** 是否自动隐藏 */
+    isAutoHide: boolean;
+    /** 是否是用户操作 */
+    userAction: boolean;
+}
+export { FloorplanData as PluginData };

package/dist/floorplan/typings/utility.d.ts

@@ -0,0 +1,2 @@
+export declare type RecordKeys<T> = T extends Record<infer P, any> ? P : any;
+export declare type RecordValue<T> = T extends Record<any, infer P> ? P : any;

package/dist/floorplan/utils/constant.d.ts

@@ -0,0 +1,22 @@
+export declare const enum FloorplanErrorType {
+    /** 意料之外的错误 */
+    UnknownError = "UnknownError",
+    /** 数据未加载 */
+    DataNotLoaded = "DataNotLoaded",
+    /** 展示过程被隐藏打断 */
+    BreakOffByHide = "BreakOffByHide",
+    /** 展示过程中插件被禁用 */
+    BreakOffByDisable = "BreakOffByDisable",
+    /** 模型未加载完成 */
+    ModelNotLoaded = "ModelNotLoaded",
+    /** Five changeMode 行为不符合预期 */
+    ChangeModeError = "ChangeModeError",
+    /** Five updateCamera 行为不符合预期 */
+    UpdateCameraError = "UpdateCameraError"
+}
+/** 户型图展示 & 模型消失的默认时间 */
+export declare const SHOW_ANIME_DURATION = 500;
+/** Five camera 默认 fov */
+export declare const FIVE_CAMERA_DEFAULT_FOV = 80;
+/** 展示户型图时，默认模型的透明度 */
+export declare const DEFAULT_SHOW_MODEL_OPACITY = 0.01;

package/dist/floorplan/utils/correctFiveState.d.ts

@@ -0,0 +1,15 @@
+import type { Five, Mode } from '@realsee/five';
+export interface ShowState {
+    latitude: number;
+    longitude: number;
+    fov: number;
+    mode: Mode;
+}
+/** 判断当前状态是否可以展示户型图 */
+export declare function checkShowState(five: Five, showState: ShowState): boolean;
+/** 更改 Five 状态到展示户型图的状态
+ * 1. 判断状态不符合时，会纠正到正确的状态
+ * 2. 内置了相应的动画时间计算
+ * 3. 纠正成功会返回 true，失败「可能会被用户行为中断」会返回 false
+ */
+export default function correctFiveState(five: Five, showState: ShowState, userAction?: boolean): Promise<void>;

package/dist/floorplan/utils/formatData.d.ts

@@ -0,0 +1,5 @@
+import type { Five } from '@realsee/five';
+import type { FloorplanData, FloorplanExtraObject, FloorplanExtraObject3D } from '../typings/floorplanData';
+import type { FloorplanServerData } from '../typings/floorplanServerData';
+export default function formatData(data: FloorplanServerData): Promise<FloorplanData>;
+export declare function formatExtraObjects(data: FloorplanExtraObject3D[], five: Five, floorplanData: FloorplanData): FloorplanExtraObject[];

package/dist/floorplan/utils/formatPosition.d.ts

@@ -0,0 +1,36 @@
+import type { Five } from '@realsee/five';
+import type { Vector2Position } from '../../typings/math.type';
+import type { FloorplanData, FloorplanBounding } from '../typings/floorplanData';
+export declare function pathD(points: Vector2Position[], options?: {
+    needZ?: boolean;
+    needA?: Record<number, string>;
+    format?: (vector: Vector2Position) => Vector2Position;
+}): string;
+/** 把户型图上点点位转换到 SVG 上的点位 */
+export default function formatFloorplanPoint({ x, y }: Vector2Position, bounding: FloorplanBounding): {
+    x: number;
+    y: number;
+};
+/** 模型坐标转户型图坐标 */
+export declare function modelPosition2FloorplanPosition(position: {
+    x: number;
+    y: number;
+    z: number;
+}, floorplanData: FloorplanData): {
+    x: number;
+    y: number;
+};
+/** 户型图点位转在图片上的相对坐标 */
+export declare function floorplanPosition2ImagePosition(position: {
+    x: number;
+    y: number;
+}, floorplanData: FloorplanData): {
+    x: number;
+    y: number;
+};
+/** 求三维坐标点所在的楼层 */
+export declare function getFloorIndexFromModelPosition(position: {
+    x: number;
+    y: number;
+    z: number;
+}, five: Five): number;

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export * from './components';
+export * from './ModelViewPlugin';
+export * from './CSS3DRenderPlugin';
+export * from './PanoCursorRaycasterPlugin';
+export * from './ModelRoomLabelPlugin';
+export * from './floorplan';
+export * from './ModelChassisCompassPlugin';
+export * from './ModelEntryDoorGuidePlugin';
+export * from './CameraMovementPlugin';
+export * from './PanoRulerPlugin';
+export * from './PanoRulerProPlugin';
+export * from './PanoCompassPlugin';
+export * from './PanoMeasurePlugin';
+export * from './PanoSpatialTagPlugin';
+export * from './ModelItemLabelPlugin';
+export * from './ModelTVVideoPlugin';
+export * from './ItemLabelPlugin';
+export * from './PanoDoorLabelPlugin';
+export * from './GuideLinePlugin';
+export * from './CruisePlugin';
+export * from './PanoTagPlugin';
+export * from './Object3DHelperPlugin';
+export * as Util from './shared-utils';

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

@@ -0,0 +1,48 @@
+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 let originOpacity: {
+    opacity: number;
+} | null;
+export declare abstract class BaseController<T extends BaseHelper = BaseHelper, K extends THREE.Object3D = THREE.Object3D> {
+    hooks: Subscribe<HelperEventMap>;
+    helperObject3D: T;
+    originObject3D: K;
+    protected camera: THREE.Camera;
+    protected model: THREE.Object3D;
+    protected scene: THREE.Scene;
+    protected container: HTMLElement;
+    protected domEvents: DomEvents;
+    protected isDragging: boolean;
+    protected onRender: () => void;
+    protected enabled: boolean;
+    constructor(camera: THREE.Camera, model: THREE.Object3D, originObject3D: K, helperObject3D: T, container: HTMLElement, scene: THREE.Scene, onRender?: () => void);
+    initialHelperPosition(): void;
+    initialHelperQuaternion(): void;
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    setOpacity(opacity: number): void;
+    restoreOpacity(): void;
+    setOriginOpacityProperty(): void;
+    updateHelperPosition(): void;
+    updateHelperQuaternion(): void;
+    applyHelperMatrix4(matrix4: THREE.Matrix4): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    applyHelperScaleMatrix4(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 render(): 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/shared-utils/Object3DHelper/Base/BaseHelper.d.ts

@@ -0,0 +1,91 @@
+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;
+    protected onRender: () => any;
+    get helperObject(): Object3D;
+    constructor(originObject3D: OriginObject3D, config?: {
+        onRender?: () => any;
+    });
+    render(): void;
+    show(): void;
+    hide(): void;
+    updatePosition(): void;
+    updateQuaternion(): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
+        origin?: THREE.Vector3;
+        helperOrigin?: THREE.Vector3;
+    }): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    abstract showDraggingHelper(directions?: Direction[]): 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;
+    };
+}
+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 showDraggingHelper(directions: 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 plane?: THREE.Mesh;
+    abstract updatePoints(): void;
+    abstract enable(): void;
+    abstract disable(): void;
+}
+export {};

package/dist/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/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/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/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;
+    };
+    dragPointInCenterBottom?: boolean | null;
+    dragPointInCenterLeft?: 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/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 helperObject3DQuaternion;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    initialHelperQuaternion(): void;
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private dragging;
+    private rotate;
+    private dragEnd;
+    private getAngleHelper;
+    private setAngleHelperStart;
+    private setAngleHelperLength;
+    private setTipsAngle;
+    private setTipsPosition;
+}

package/dist/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/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/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/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);
+    show(): void;
+    showDraggingHelper(directions: Direction[]): void;
+    dispose(): void;
+}

package/dist/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/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/shared-utils/Object3DHelper/Helper/RectangleScaleHelper.d.ts

@@ -0,0 +1,40 @@
+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 type { 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>;
+    plane?: THREE.Mesh<THREE.PlaneGeometry, THREE.MeshBasicMaterial>;
+    private css3DRenderer;
+    private camera;
+    private scene;
+    private container;
+    private enabled;
+    constructor(originObject3D: T, container: Element, camera: THREE.Camera, scene: THREE.Scene);
+    updatePosition(): void;
+    updateQuaternion(): void;
+    applyMatrix4(matrix: THREE.Matrix4): void;
+    showDraggingHelper(): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
+        origin?: Vector3;
+        helperOrigin?: Vector3;
+    }): void;
+    updatePoints(): void;
+    applyHelperQuaternion(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/shared-utils/Object3DHelper/Helper/RotateHelper.d.ts

@@ -0,0 +1,55 @@
+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;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    hide(): void;
+    show(): void;
+    showDraggingHelper(directions: 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/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';