@realsee/dnalogel 3.20.7 → 3.21.1

package/libs/Sculpt/Meshes/Prism.d.ts

@@ -0,0 +1,31 @@
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import { type AnyPosition, type AnyPositions } from '../../shared-utils/positionToVector3';
+import { AreaMesh, type AreaData } from './Area';
+import * as THREE from 'three';
+import type { LineStyle } from '../utils/color';
+import type { ColoredMeshStyle } from '../utils/three/ColoredMesh';
+export type PrismStyle = ColoredMeshStyle & LineStyle;
+export interface PrismData extends AreaData {
+    heightPoint: AnyPosition;
+}
+/**
+ * @description: 多棱柱
+ */
+export declare class PrismMesh extends IObject3D {
+    name: string;
+    heightPoint: THREE.Vector3;
+    bottomPolygon: AreaMesh;
+    topPolygon: AreaMesh;
+    get color(): THREE.Color;
+    get lineWidth(): number;
+    get lineColor(): THREE.Color;
+    private edgePlanes;
+    constructor(params?: Partial<PrismData & PrismStyle>);
+    setStyle(params: Partial<PrismStyle>): void;
+    setPoints(params: Partial<PrismData>): void;
+    highlight(): void;
+    unhighlight(): void;
+    setBottomPoints(points: AnyPositions): void;
+    setTopHeightPoint(heightPoint: THREE.Vector3): void;
+    private setEdgePlanes;
+}

package/libs/Sculpt/Meshes/Prism.js

@@ -0,0 +1,78 @@
+var f = Object.defineProperty;
+var d = (n, i, t) => i in n ? f(n, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[i] = t;
+var s = (n, i, t) => (d(n, typeof i != "symbol" ? i + "" : i, t), t);
+import { IObject3D as P } from "../../shared-utils/three/IObject3D.js";
+import { anyPositionToVector3 as r } from "../../shared-utils/positionToVector3.js";
+import { AreaMesh as m } from "./Area.js";
+import "hammerjs";
+import * as a from "three";
+import "@realsee/five";
+import "../../vendor/@tweenjs/tween/dist/tween.esm.js.js";
+import "../../CSS3DRenderPlugin/utils/three/CSS3DRender.js";
+import "../../CSS3DRenderPlugin/utils/generateBehindFiveElement.js";
+import { notNil as y } from "../../shared-utils/isNil.js";
+import { PolygonMesh as c } from "./Polygon.js";
+import { LineMesh as p } from "./Line.js";
+class W extends P {
+  constructor(t) {
+    super();
+    s(this, "name", "PrismMesh");
+    s(this, "heightPoint");
+    s(this, "bottomPolygon", new m());
+    s(this, "topPolygon", new m());
+    s(this, "edgePlanes", new P());
+    this.topPolygon.name = "TopPolygon", this.bottomPolygon.name = "BottomPolygon", this.edgePlanes.name = "EdgePlanes", this.addIfNotExists(this.bottomPolygon), t && this.setPoints(t), t && this.setStyle(t);
+  }
+  get color() {
+    return this.bottomPolygon.color;
+  }
+  get lineWidth() {
+    return this.bottomPolygon.lineWidth;
+  }
+  get lineColor() {
+    return this.bottomPolygon.lineColor;
+  }
+  setStyle(t) {
+    this.bottomPolygon.setStyle(t), this.topPolygon.setStyle(t), this.edgePlanes.children.forEach((o) => {
+      (o instanceof p || o instanceof c) && o.setStyle(t);
+    });
+  }
+  setPoints(t) {
+    y(t.points) && this.setBottomPoints(t.points), y(t.heightPoint) && this.setTopHeightPoint(r(t.heightPoint));
+  }
+  highlight() {
+    this.bottomPolygon.highlight(), this.topPolygon.highlight(), this.edgePlanes.children.forEach((t) => {
+      typeof t.highlight == "function" && t.highlight();
+    });
+  }
+  unhighlight() {
+    this.bottomPolygon.unhighlight(), this.topPolygon.unhighlight(), this.edgePlanes.children.forEach((t) => {
+      typeof t.unhighlight == "function" && t.unhighlight();
+    });
+  }
+  setBottomPoints(t) {
+    const o = t.map(r);
+    this.bottomPolygon.setPoints(o), this.heightPoint && this.setTopHeightPoint(this.heightPoint);
+  }
+  setTopHeightPoint(t) {
+    this.heightPoint = t, this.addIfNotExists(this.topPolygon);
+    const o = this.bottomPolygon.projectPoint(t), g = new a.Vector3().subVectors(t, o);
+    this.up.copy(g.clone().normalize());
+    const l = this.bottomPolygon.points.map((h) => h.clone().add(g));
+    this.topPolygon.setPoints(l), this.setEdgePlanes();
+  }
+  setEdgePlanes() {
+    const t = this.bottomPolygon.points, o = this.topPolygon.points;
+    this.addIfNotExists(this.edgePlanes), this.edgePlanes.removeChildren(), t.forEach((g, e) => {
+      if (e === 0)
+        return;
+      const l = new c({ color: this.color });
+      l.setPoints([t[e - 1], t[e], o[e], o[e - 1]]);
+      const h = new p({ lineColor: this.lineColor, lineWidth: this.lineWidth });
+      h.name = "EdgeLine", h.setPoints([t[e - 1], o[e - 1]]), this.edgePlanes.add(l, h);
+    });
+  }
+}
+export {
+  W as PrismMesh
+};

package/libs/Sculpt/Meshes/Rectangle.d.ts

@@ -0,0 +1,24 @@
+import { type AnyPositions } from '../../shared-utils/positionToVector3';
+import * as THREE from 'three';
+import PolygonMesh from './Polygon';
+import { RectangleGeometry } from '../utils/three/RectangleGeometry';
+import type { PointsData } from '../utils/data';
+import type { ColoredMeshStyle } from '../utils/three/ColoredMesh';
+export type RectangleStyle = ColoredMeshStyle;
+export type RectangleData = PointsData;
+/**
+ * @description: 矩形
+ */
+export declare class RectangleMesh extends PolygonMesh {
+    name: string;
+    meshFont: THREE.Mesh<RectangleGeometry, THREE.MeshBasicMaterial>;
+    meshBackground: THREE.Mesh<RectangleGeometry, THREE.MeshBasicMaterial>;
+    get color(): THREE.Color;
+    /**
+     * @description: 构造矩形所需的三个点
+     */
+    get builtPoints(): THREE.Vector3[];
+    get sortedPoint(): THREE.Vector3[];
+    constructor(params?: Partial<RectangleStyle & RectangleData>);
+    setPoints(points: AnyPositions): void;
+}

package/libs/Sculpt/Meshes/Rectangle.js

@@ -0,0 +1,49 @@
+var c = Object.defineProperty;
+var h = (r, e, t) => e in r ? c(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var i = (r, e, t) => (h(r, typeof e != "symbol" ? e + "" : e, t), t);
+import { anyPositionToVector3 as a } from "../../shared-utils/positionToVector3.js";
+import "hammerjs";
+import * as u from "three";
+import "@realsee/five";
+import "../../vendor/@tweenjs/tween/dist/tween.esm.js.js";
+import "../../CSS3DRenderPlugin/utils/three/CSS3DRender.js";
+import "../../CSS3DRenderPlugin/utils/generateBehindFiveElement.js";
+import { notNil as s } from "../../shared-utils/isNil.js";
+import { PolygonMesh as f } from "./Polygon.js";
+import { RectangleGeometry as g } from "../utils/three/RectangleGeometry.js";
+import { getBetterNormal as d } from "../utils/getBetterNormal.js";
+import { Sculpt as v } from "../index.js";
+class T extends f {
+  constructor(t) {
+    super(t);
+    i(this, "name", "RectangleMesh");
+  }
+  get color() {
+    return this.meshFont.material.color;
+  }
+  /**
+   * @description: 构造矩形所需的三个点
+   */
+  get builtPoints() {
+    var t, o;
+    return (o = (t = this.meshFont) == null ? void 0 : t.geometry) == null ? void 0 : o.points.slice(0, 3);
+  }
+  get sortedPoint() {
+    return [this.points[0], this.points[2], this.points[1], this.points[3]].filter(s);
+  }
+  setPoints(t) {
+    const o = t.map(a).filter(s);
+    if (o.length < 3) {
+      console.error("Invalid position");
+      return;
+    }
+    if (t.length === 3) {
+      const [n, m, p] = o, l = new u.Vector3().addVectors(n, m).sub(p);
+      o.push(l);
+    }
+    this.up.copy(d(o, v.modules.five.camera.position)), this.points = o, this.geometry = new g(o), this.planeHelperNeedUpdate = !0;
+  }
+}
+export {
+  T as RectangleMesh
+};

package/libs/Sculpt/Meshes/RectangleWithEdge.d.ts

@@ -0,0 +1,20 @@
+import type { AnyPositions } from '../../shared-utils/positionToVector3';
+import { RectangleMesh, type RectangleData, type RectangleStyle } from './Rectangle';
+import { PolylineMesh } from './Polyline';
+import type { LineStyle } from '../utils/color';
+import * as THREE from 'three';
+export type RectangleWithEdgeMeshStyle = RectangleStyle & LineStyle;
+/**
+ * @description: 带边线的矩形
+ */
+export declare class RectangleWithEdgeMesh extends RectangleMesh {
+    name: string;
+    get lineWidth(): number;
+    get lineColor(): THREE.Color;
+    protected line: PolylineMesh;
+    constructor(params?: Partial<RectangleWithEdgeMeshStyle & RectangleData>);
+    setPoints(points: AnyPositions): void;
+    setStyle(style: Partial<RectangleWithEdgeMeshStyle>): void;
+    highlight(): void;
+    unhighlight(): void;
+}

package/libs/Sculpt/Meshes/RectangleWithEdge.js

@@ -0,0 +1,49 @@
+var r = Object.defineProperty;
+var o = Object.getOwnPropertySymbols;
+var u = Object.prototype.hasOwnProperty, c = Object.prototype.propertyIsEnumerable;
+var d = (e, s, t) => s in e ? r(e, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[s] = t;
+var g = (e, s) => {
+  var t = {};
+  for (var i in e)
+    u.call(e, i) && s.indexOf(i) < 0 && (t[i] = e[i]);
+  if (e != null && o)
+    for (var i of o(e))
+      s.indexOf(i) < 0 && c.call(e, i) && (t[i] = e[i]);
+  return t;
+};
+var h = (e, s, t) => (d(e, typeof s != "symbol" ? s + "" : s, t), t);
+import { RectangleMesh as p } from "./Rectangle.js";
+import { PolylineMesh as f } from "./Polyline.js";
+class S extends p {
+  constructor(t) {
+    const l = t != null ? t : {}, { points: i } = l, n = g(l, ["points"]);
+    super();
+    h(this, "name", "RectangleWithEdgeMesh");
+    h(this, "line", new f());
+    i && this.setPoints(i), n && this.setStyle(n);
+  }
+  get lineWidth() {
+    return this.line.lineWidth;
+  }
+  get lineColor() {
+    return this.line.lineColor;
+  }
+  setPoints(t) {
+    if (super.setPoints(t), this.points) {
+      const i = this.points;
+      this.line.setPoints([i[0], i[2], i[1], i[3], i[0]]), this.addIfNotExists(this.line);
+    }
+  }
+  setStyle(t) {
+    super.setStyle(t), this.line.setStyle(t);
+  }
+  highlight() {
+    super.highlight(), this.line.highlight();
+  }
+  unhighlight() {
+    super.unhighlight(), this.line.unhighlight();
+  }
+}
+export {
+  S as RectangleWithEdgeMesh
+};

package/libs/Sculpt/Modules/Cursor.d.ts

@@ -0,0 +1,13 @@
+type CursorType = 'auto' | 'pen' | 'pen-forbidden' | 'pen-crosshair' | 'pne-polygon' | 'pen-circle' | 'crosshair-rectangle' | 'crosshair-circle';
+export declare class Cursor {
+    private container;
+    constructor(container: HTMLElement);
+    /**
+     * @param type - The type of the cursor.
+     */
+    setType(type: CursorType): void;
+    tip(tip: string): () => void;
+    closeTip(): void;
+    reset(): void;
+}
+export {};

package/libs/Sculpt/Modules/Cursor.js

@@ -0,0 +1,37 @@
+var t = Object.defineProperty;
+var c = (s, r, e) => r in s ? t(s, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[r] = e;
+var o = (s, r, e) => (c(s, typeof r != "symbol" ? r + "" : r, e), e);
+const n = {
+  auto: "",
+  pen: "",
+  "pen-forbidden": "",
+  "pen-crosshair": "",
+  "pne-polygon": "",
+  "pen-circle": "",
+  "crosshair-rectangle": "",
+  "crosshair-circle": ""
+};
+class a {
+  constructor(r) {
+    o(this, "container");
+    this.container = r;
+  }
+  /**
+   * @param type - The type of the cursor.
+   */
+  setType(r) {
+    const e = n[r];
+    e ? this.container.style.cursor = `url(${e}), auto` : this.container.style.cursor = r;
+  }
+  tip(r) {
+    return () => this.closeTip();
+  }
+  closeTip() {
+  }
+  reset() {
+    this.container.style.cursor = "auto";
+  }
+}
+export {
+  a as Cursor
+};

package/libs/Sculpt/Modules/Global.d.ts

@@ -0,0 +1,20 @@
+import type { Five } from '@realsee/five';
+import { Cursor } from './Cursor';
+import { PointSelector } from '../../shared-utils/three/PointSelector';
+import { FiveDomEvents } from '../../shared-utils/five/FiveDomEvents';
+import { Object3DHelperController } from '../../Object3DHelperPlugin';
+declare class GlobalModules {
+    five: Five;
+    _cursor: Cursor;
+    _pointSelector: PointSelector;
+    _fiveDomEvents: FiveDomEvents;
+    _object3DHelper: Object3DHelperController;
+    inited: boolean;
+    get cursor(): Cursor;
+    get pointSelector(): PointSelector;
+    get fiveDomEvents(): FiveDomEvents;
+    get object3DHelper(): Object3DHelperController;
+    init: (five: Five) => void;
+}
+declare const globalModules: GlobalModules;
+export { globalModules };

package/libs/Sculpt/Modules/Global.js

@@ -0,0 +1,45 @@
+var o = Object.defineProperty;
+var n = (i, e, r) => e in i ? o(i, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : i[e] = r;
+var t = (i, e, r) => (n(i, typeof e != "symbol" ? e + "" : e, r), r);
+import { Cursor as s } from "./Cursor.js";
+import { PointSelector as l } from "../../shared-utils/three/PointSelector.js";
+import { FiveDomEvents as h } from "../../shared-utils/five/FiveDomEvents.js";
+import { Object3DHelperController as f } from "../../Object3DHelperPlugin/Controller.js";
+class c {
+  constructor() {
+    t(this, "five");
+    t(this, "_cursor");
+    t(this, "_pointSelector");
+    t(this, "_fiveDomEvents");
+    t(this, "_object3DHelper");
+    t(this, "inited", !1);
+    t(this, "init", (e) => {
+      this.inited = !0, this.five = e;
+    });
+  }
+  get cursor() {
+    if (!this.inited)
+      throw new Error("Global not inited");
+    return this._cursor ? this._cursor : (this._cursor = new s(this.five.getElement()), this._cursor);
+  }
+  get pointSelector() {
+    if (!this.inited)
+      throw new Error("Global not inited");
+    return this._pointSelector ? this._pointSelector : (this._pointSelector = new l(this.five), this._pointSelector);
+  }
+  get fiveDomEvents() {
+    if (!this.inited)
+      throw new Error("Global not inited");
+    return this._fiveDomEvents ? this._fiveDomEvents : (this._fiveDomEvents = new h(this.five), this._fiveDomEvents);
+  }
+  get object3DHelper() {
+    if (!this.inited)
+      throw new Error("Global not inited");
+    return this._object3DHelper ? this._object3DHelper : (this._object3DHelper = new f(this.five), this._object3DHelper);
+  }
+}
+const v = new c();
+window.globalModules = v;
+export {
+  v as globalModules
+};

package/libs/Sculpt/Objects/Base/Editor.d.ts

@@ -0,0 +1,21 @@
+import type * as THREE from 'three';
+import { IObject3D } from '../../../shared-utils/three/IObject3D';
+import type { AddObject3DHelperConfig } from '../../../Object3DHelperPlugin';
+export declare class BaseEditor<OriginObject extends THREE.Object3D = THREE.Object3D> extends IObject3D {
+    protected originObject: OriginObject;
+    constructor(originObject: OriginObject);
+    /**
+     * @description: 开启编辑器
+     */
+    enable(): void;
+    /**
+     * @description: 禁用编辑器
+     */
+    disable(): void;
+}
+export declare class BaseEditorWithObjectHelper<OriginObject extends THREE.Object3D = THREE.Object3D> extends BaseEditor<OriginObject> {
+    private objectHelperConfig;
+    constructor(originObject: OriginObject, objectHelperConfig?: AddObject3DHelperConfig | (() => AddObject3DHelperConfig));
+    enable(): void;
+    disable(): void;
+}

package/libs/Sculpt/Objects/Base/Editor.js

@@ -0,0 +1,52 @@
+var l = Object.defineProperty;
+var s = Object.getOwnPropertySymbols;
+var p = Object.prototype.hasOwnProperty, j = Object.prototype.propertyIsEnumerable;
+var i = (o, t, e) => t in o ? l(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e, c = (o, t) => {
+  for (var e in t || (t = {}))
+    p.call(t, e) && i(o, e, t[e]);
+  if (s)
+    for (var e of s(t))
+      j.call(t, e) && i(o, e, t[e]);
+  return o;
+};
+var r = (o, t, e) => (i(o, typeof t != "symbol" ? t + "" : t, e), e);
+import { Sculpt as b } from "../../index.js";
+import { IObject3D as d } from "../../../shared-utils/three/IObject3D.js";
+class g extends d {
+  constructor(e) {
+    super();
+    r(this, "originObject");
+    this.originObject = e;
+  }
+  /**
+   * @description: 开启编辑器
+   */
+  enable() {
+    this.originObject.add(this);
+  }
+  /**
+   * @description: 禁用编辑器
+   */
+  disable() {
+    this.originObject.remove(this);
+  }
+}
+class H extends g {
+  constructor(e, n) {
+    super(e);
+    r(this, "objectHelperConfig");
+    this.objectHelperConfig = n;
+  }
+  enable() {
+    super.enable();
+    const e = typeof this.objectHelperConfig == "function" ? this.objectHelperConfig() : this.objectHelperConfig;
+    b.modules.object3DHelper.addObject3DHelper(this.originObject, c({ positionFrom: "boundingBox" }, e));
+  }
+  disable() {
+    super.disable(), b.modules.object3DHelper.removeObject3DHelper(this.originObject);
+  }
+}
+export {
+  g as BaseEditor,
+  H as BaseEditorWithObjectHelper
+};

package/libs/Sculpt/Objects/Base/index.d.ts

@@ -0,0 +1,60 @@
+import type { FiveDomEventMap } from '../../../shared-utils/five/FiveDomEvents';
+import { IObject3D } from '../../../shared-utils/three/IObject3D';
+import type { BaseEditor } from './Editor';
+import type { RequiredDeep } from 'type-fest';
+import type * as THREE from 'three';
+export interface BaseImportData {
+    id?: string;
+    type: string;
+}
+export interface BaseExportData extends RequiredDeep<BaseImportData> {
+}
+export interface BaseObjectConfig {
+    /**
+     * @description: 是否可以编辑
+     * @default true
+     */
+    canEdit: boolean;
+    /**
+     * @description: 是否以一种半透明的方式显示遮挡的部分
+     * @default true
+     */
+    occlusionVisibility: boolean;
+}
+/**
+ * @description: 基础对象
+ */
+export declare abstract class BaseObject<ImportData extends BaseImportData = BaseImportData, ExportData extends BaseExportData = any, Config extends BaseObjectConfig = BaseObjectConfig> extends IObject3D {
+    name: string;
+    readonly isSculptObject = true;
+    draggable: boolean;
+    /**
+     * @description: 是否被选中
+     */
+    selected: boolean;
+    /**
+     * @description: 配置
+     */
+    config: Config;
+    protected editor: BaseEditor;
+    abstract type: string;
+    /**
+     * @description: 物体导出数据
+     */
+    abstract get data(): ExportData;
+    protected get baseData(): {
+        id: string;
+        type: string;
+    };
+    protected get pointSelector(): import("../../../shared-utils/three/PointSelector").PointSelector;
+    constructor(data?: Partial<ImportData>, config?: Partial<Config>);
+    on: <T extends keyof FiveDomEventMap>(event: T, callback: FiveDomEventMap[T]) => void;
+    off: (event: keyof FiveDomEventMap, callback: (e: import("../../../shared-utils/five/FiveDomEvents").FiveDomEvent) => any, ...args: any[]) => void;
+    stopCreating(): void;
+    delete(): void;
+    highlight(): void;
+    unhighlight(): void;
+    protected applyObjectMatrixWorld<P extends THREE.Vector3 | THREE.Vector3[]>(point: P): P;
+    protected applyObjectQuaternion<P extends THREE.Vector3 | THREE.Vector3[]>(point: P): P;
+    abstract create(...args: any): any;
+}

package/libs/Sculpt/Objects/Base/index.js

@@ -0,0 +1,77 @@
+var f = Object.defineProperty;
+var u = Object.getOwnPropertySymbols;
+var b = Object.prototype.hasOwnProperty, g = Object.prototype.propertyIsEnumerable;
+var n = (s, t, e) => t in s ? f(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e, d = (s, t) => {
+  for (var e in t || (t = {}))
+    b.call(t, e) && n(s, e, t[e]);
+  if (u)
+    for (var e of u(t))
+      g.call(t, e) && n(s, e, t[e]);
+  return s;
+};
+var r = (s, t, e) => (n(s, typeof t != "symbol" ? t + "" : t, e), e);
+import { hotkeys as p } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { Sculpt as o } from "../../index.js";
+import { IObject3D as m } from "../../../shared-utils/three/IObject3D.js";
+const a = /* @__PURE__ */ new Map();
+class x extends m {
+  constructor(e, l) {
+    super();
+    r(this, "name", "Sculpt");
+    r(this, "isSculptObject", !0);
+    r(this, "draggable");
+    /**
+     * @description: 是否被选中
+     */
+    r(this, "selected");
+    /**
+     * @description: 配置
+     */
+    r(this, "config");
+    r(this, "editor");
+    r(this, "on", (e, l, ...i) => o.modules.fiveDomEvents.addEventListener(this, e, l, ...i));
+    r(this, "off", (...e) => o.modules.fiveDomEvents.addEventListener(this, ...e));
+    e != null && e.id && (this.uuid = e.id), this.config = d({ canEdit: !0, occlusionVisibility: !0 }, l), e != null && e.style && (e.style.occlusionVisibility = this.config.occlusionVisibility), this.config.canEdit && (p("backspace, delete", () => {
+      this.selected && this.delete();
+    }), this.on("click", () => {
+      var c, h;
+      if (this.pointSelector.enabled)
+        return;
+      let i = a.get(this.parent.uuid);
+      i && (i.selected = !1, i.unhighlight(), (c = i.editor) == null || c.disable()), a.set(this.parent.uuid, this), this.selected = !0, this.highlight(), (h = this.editor) == null || h.enable();
+    }), p("esc", () => {
+      var i;
+      this.selected = !1, this.unhighlight(), !this.pointSelector.enabled && ((i = this.editor) == null || i.disable());
+    }));
+  }
+  get baseData() {
+    return {
+      id: this.uuid,
+      type: this.type
+    };
+  }
+  get pointSelector() {
+    return o.modules.pointSelector;
+  }
+  stopCreating() {
+    o.modules.pointSelector.disable();
+  }
+  delete() {
+    var e;
+    this.removeFromParent(), (e = this.editor) == null || e.disable();
+  }
+  highlight() {
+  }
+  unhighlight() {
+  }
+  applyObjectMatrixWorld(e) {
+    return Array.isArray(e) ? e.map((l) => l.clone().applyMatrix4(this.matrixWorld)) : e.clone().applyMatrix4(this.matrixWorld);
+  }
+  applyObjectQuaternion(e) {
+    const l = this.quaternion.clone();
+    return Array.isArray(e) ? e.map((i) => i.clone().applyQuaternion(l)) : e.clone().applyQuaternion(l);
+  }
+}
+export {
+  x as BaseObject
+};

package/libs/Sculpt/Objects/Box/Editor.d.ts

@@ -0,0 +1,5 @@
+import type { Box } from '.';
+import { BaseEditorWithObjectHelper } from '../Base/Editor';
+export declare class BoxEditor extends BaseEditorWithObjectHelper<Box> {
+    constructor(originObject: Box);
+}

package/libs/Sculpt/Objects/Box/Editor.js

@@ -0,0 +1,44 @@
+import { BaseEditorWithObjectHelper as a } from "../Base/Editor.js";
+import * as c from "three";
+class m extends a {
+  constructor(e) {
+    super(e, () => {
+      const i = () => {
+        var s, t;
+        const o = (s = e.boxMesh.topPlane.getGeometryInfo()) == null ? void 0 : s.center, n = (t = e.boxMesh.bottomPlane.getGeometryInfo()) == null ? void 0 : t.center, r = new c.Vector3().lerpVectors(o, n, 0.5);
+        return { topCenter: o, bottomCenter: n, boxCenter: r };
+      };
+      return {
+        positionFrom: "boundingBox",
+        yAxis: e.boxMesh.bottomPlane.up,
+        scaleHelper: {
+          enable: !0,
+          positions: () => {
+            const o = i();
+            return [
+              {
+                id: "top",
+                handlePosition: o.topCenter,
+                basePosition: o.bottomCenter
+              },
+              {
+                id: "bottom",
+                handlePosition: o.bottomCenter,
+                basePosition: o.topCenter
+              }
+            ];
+          },
+          scaleCallback: (o) => {
+            const { intersectPoint: n, scalePosition: r } = o, { id: s } = r, { boxMesh: t } = e;
+            s === "top" ? t.setTopHeightPoint(n) : s === "bottom" && t.setPoints({
+              points: t.topPlane.points.map((p) => p.clone().add(n.clone().sub(r.basePosition)))
+            });
+          }
+        }
+      };
+    });
+  }
+}
+export {
+  m as BoxEditor
+};

package/libs/Sculpt/Objects/Box/index.d.ts

@@ -0,0 +1,28 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import { BoxMesh, type BoxData, type BoxStyle } from '../../Meshes/Box';
+import type { LiteralString } from '../../typings/utils.type';
+export interface BoxImportData extends BaseImportData, BoxData {
+    type: LiteralString<'Box'>;
+    style?: Partial<BoxStyle>;
+}
+export declare class Box extends BaseObject<BoxImportData> {
+    readonly type = "Box";
+    boxMesh: BoxMesh;
+    get data(): {
+        points: [number, number, number][];
+        heightPoint: [number, number, number];
+        style: {
+            color: number;
+            lineWidth: number;
+            lineColor: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: BoxImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<BoxStyle>): Promise<void>;
+}
+export declare function createBox(boxMesh: BoxMesh, pointSelector: PointSelector): Promise<void>;