@realsee/dnalogel 3.20.7 → 3.21.0

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

@@ -0,0 +1,107 @@
+var B = Object.defineProperty, E = Object.defineProperties;
+var C = Object.getOwnPropertyDescriptors;
+var P = Object.getOwnPropertySymbols;
+var H = Object.prototype.hasOwnProperty, O = Object.prototype.propertyIsEnumerable;
+var p = (o, e, t) => e in o ? B(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t, c = (o, e) => {
+  for (var t in e || (e = {}))
+    H.call(e, t) && p(o, t, e[t]);
+  if (P)
+    for (var t of P(e))
+      O.call(e, t) && p(o, t, e[t]);
+  return o;
+}, M = (o, e) => E(o, C(e));
+var d = (o, e, t) => (p(o, typeof e != "symbol" ? e + "" : e, t), t);
+var b = (o, e, t) => new Promise((r, i) => {
+  var a = (s) => {
+    try {
+      n(t.next(s));
+    } catch (h) {
+      i(h);
+    }
+  }, m = (s) => {
+    try {
+      n(t.throw(s));
+    } catch (h) {
+      i(h);
+    }
+  }, n = (s) => s.done ? r(s.value) : Promise.resolve(s.value).then(a, m);
+  n((t = t.apply(o, e)).next());
+});
+import { hotkeys as L } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { BaseObject as W } from "../Base/index.js";
+import * as j from "three";
+import { BoxEditor as N } from "./Editor.js";
+import { BoxMesh as w } from "../../Meshes/Box.js";
+import { createRectangle as R } from "../Rectangle/index.js";
+import { LineMesh as T } from "../../Meshes/Line.js";
+import { getNormal as U } from "../../../shared-utils/three/getNormal.js";
+import { rayOnLine as k } from "../../utils/three/rayOnLine.js";
+import { Sculpt as z } from "../../index.js";
+import { vector3ToArray as v } from "../../../shared-utils/three/vector3ToArray.js";
+class Z extends W {
+  constructor(t, r) {
+    super(t, r);
+    d(this, "type", "Box");
+    d(this, "boxMesh");
+    this.editor = new N(this), t && (this.boxMesh = new w(c(c({}, t.style), t)), this.add(this.boxMesh)), L("esc", () => {
+      this.stopCreating();
+    });
+  }
+  get data() {
+    return M(c({}, this.baseData), {
+      points: v(this.applyObjectMatrixWorld(this.boxMesh.bottomPlane.points)),
+      heightPoint: v(this.applyObjectMatrixWorld(this.boxMesh.heightPoint)),
+      style: {
+        color: this.boxMesh.color.getHex(),
+        lineWidth: this.boxMesh.lineWidth,
+        lineColor: this.boxMesh.lineColor.getHex()
+      }
+    });
+  }
+  highlight() {
+    var t;
+    (t = this.boxMesh) == null || t.highlight();
+  }
+  unhighlight() {
+    var t;
+    (t = this.boxMesh) == null || t.unhighlight();
+  }
+  create(t) {
+    return b(this, null, function* () {
+      this.removeChildren(), this.boxMesh = new w(t), this.add(this.boxMesh), yield A(this.boxMesh, this.pointSelector), this.editor.enable();
+    });
+  }
+}
+function A(o, e) {
+  return b(this, null, function* () {
+    return yield R(o.bottomPlane, e), new Promise((t, r) => {
+      const i = o.parent;
+      if (!i) {
+        r(new Error("No container"));
+        return;
+      }
+      const a = new T(), m = U(o.bottomPlane.points).normalize(), n = o.bottomPlane.builtPoints.at(-1), s = n.clone().add(m.clone().multiplyScalar(10)), h = n.clone().sub(m.clone().multiplyScalar(10));
+      a.setPoints([s, h]), i.add(a), e.enable();
+      const f = (l) => {
+        g(), t();
+      }, x = (l) => {
+        if (!(l != null && l.raycaster))
+          return;
+        const y = k(
+          z.modules.five.camera.position,
+          l.raycaster.ray,
+          new j.Line3(s, h)
+        );
+        y && o.setPoints({ heightPoint: y });
+      }, g = () => {
+        e.off("select", f), e.off("intersectionUpdate", x), e.off("disable", u), e.disable(), i == null || i.remove(a);
+      }, u = () => {
+        g(), i == null || i.remove(o), r(new Error("Cancelled"));
+      };
+      e.on("select", f), e.on("intersectionUpdate", x), e.on("disable", u);
+    });
+  });
+}
+export {
+  Z as Box
+};

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

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

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

@@ -0,0 +1,9 @@
+import { BaseEditorWithObjectHelper as e } from "../Base/Editor.js";
+class o extends e {
+  constructor(r) {
+    super(r, () => ({ yAxis: r.circleMesh.normal }));
+  }
+}
+export {
+  o as CircleEditor
+};

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

@@ -0,0 +1,28 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { CircleData, CircleMesh } from '../../Meshes/Circle';
+import { CircleWithEdgeMesh, type CircleWithEdgeMeshStyle } from '../../Meshes/CircleWithEdge';
+import type { LiteralString } from '../../typings/utils.type';
+export interface CircleImportData extends BaseImportData, CircleData {
+    type: LiteralString<'Circle'>;
+    style?: Partial<CircleWithEdgeMeshStyle>;
+}
+export declare class Circle extends BaseObject<CircleImportData> {
+    readonly type = "Circle";
+    circleMesh: CircleWithEdgeMesh;
+    get data(): {
+        center: [number, number, number];
+        normal: [number, number, number];
+        radius: number;
+        style: {
+            color: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: CircleImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<CircleWithEdgeMeshStyle>): Promise<void>;
+}
+export declare function createCircle(circleMesh: CircleMesh, pointSelector: PointSelector): Promise<void>;

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

@@ -0,0 +1,114 @@
+var v = Object.defineProperty, x = Object.defineProperties;
+var O = Object.getOwnPropertyDescriptors;
+var M = Object.getOwnPropertySymbols;
+var T = Object.prototype.hasOwnProperty, j = Object.prototype.propertyIsEnumerable;
+var d = (t, r, e) => r in t ? v(t, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[r] = e, m = (t, r) => {
+  for (var e in r || (r = {}))
+    T.call(r, e) && d(t, e, r[e]);
+  if (M)
+    for (var e of M(r))
+      j.call(r, e) && d(t, e, r[e]);
+  return t;
+}, g = (t, r) => x(t, O(r));
+var f = (t, r, e) => (d(t, typeof r != "symbol" ? r + "" : r, e), e);
+var w = (t, r, e) => new Promise((o, i) => {
+  var a = (n) => {
+    try {
+      c(e.next(n));
+    } catch (h) {
+      i(h);
+    }
+  }, s = (n) => {
+    try {
+      c(e.throw(n));
+    } catch (h) {
+      i(h);
+    }
+  }, c = (n) => n.done ? o(n.value) : Promise.resolve(n.value).then(a, s);
+  c((e = e.apply(t, r)).next());
+});
+import { hotkeys as A } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { BaseObject as H } from "../Base/index.js";
+import * as y from "three";
+import { PolylineMesh as N } from "../../Meshes/Polyline.js";
+import { CircleEditor as U } from "./Editor.js";
+import { CircleWithEdgeMesh as b } from "../../Meshes/CircleWithEdge.js";
+import { vector3ToArray as C } from "../../../shared-utils/three/vector3ToArray.js";
+class V extends H {
+  constructor(e, o) {
+    super(e, o);
+    f(this, "type", "Circle");
+    f(this, "circleMesh");
+    this.editor = new U(this), e && (this.circleMesh = new b(m(m({}, e.style), e)), this.add(this.circleMesh)), A("esc", () => {
+      this.stopCreating();
+    });
+  }
+  get data() {
+    return g(m({}, this.baseData), {
+      center: C(this.applyObjectMatrixWorld(this.circleMesh.center)),
+      normal: C(this.applyObjectQuaternion(this.circleMesh.normal)),
+      radius: this.circleMesh.radius,
+      style: {
+        color: this.circleMesh.color.getHex()
+      }
+    });
+  }
+  highlight() {
+    var e;
+    (e = this.circleMesh) == null || e.highlight();
+  }
+  unhighlight() {
+    var e;
+    (e = this.circleMesh) == null || e.unhighlight();
+  }
+  create(e) {
+    return w(this, null, function* () {
+      this.children.forEach((i) => {
+        i.parent === this && this.remove(i);
+      }), this.children.length = 0;
+      const o = new b(e);
+      this.circleMesh = o, this.add(this.circleMesh), yield W(this.circleMesh, this.pointSelector), this.editor.enable();
+    });
+  }
+}
+function W(t, r) {
+  return new Promise((e, o) => {
+    const i = t.parent;
+    if (!i) {
+      o(new Error("No container"));
+      return;
+    }
+    const a = new N({ dashed: !0 });
+    i.add(a), r.enable();
+    let s, c;
+    const n = (l) => {
+      if (l) {
+        if (!s) {
+          s = {
+            point: l.point,
+            normal: l.face.normal
+          };
+          return;
+        }
+        s && c && (p(), e());
+      }
+    }, h = (l) => {
+      if (!l || !s)
+        return;
+      const E = new y.Plane().setFromNormalAndCoplanarPoint(s.normal, s.point);
+      if (c = l.raycaster.ray.intersectPlane(E, new y.Vector3()), c) {
+        const P = s.point.distanceTo(c);
+        t.setPoints({ center: s.point, normal: s.normal, radius: P });
+      }
+    }, p = () => {
+      r.off("select", n), r.off("intersectionUpdate", h), r.off("disable", u), r.disable(), i == null || i.remove(a);
+    }, u = () => {
+      p(), i == null || i.remove(t, a), o(new Error("Cancelled"));
+    };
+    r.on("select", n), r.on("intersectionUpdate", h), r.on("disable", u);
+  });
+}
+export {
+  V as Circle,
+  W as createCircle
+};

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

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

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

@@ -0,0 +1,41 @@
+import { BaseEditorWithObjectHelper as c } from "../Base/Editor.js";
+import * as l from "three";
+class d extends c {
+  constructor(e) {
+    super(e, () => {
+      const i = () => {
+        const t = e.cylinderMesh.topCenter, o = e.cylinderMesh.bottomCenter, n = new l.Vector3().lerpVectors(t, o, 0.5);
+        return { topCenter: t, bottomCenter: o, boxCenter: n };
+      };
+      return {
+        positionFrom: "boundingBox",
+        yAxis: e.cylinderMesh.normal,
+        scaleHelper: {
+          enable: !0,
+          positions: () => {
+            const t = i();
+            return [
+              {
+                id: "top",
+                handlePosition: t.topCenter,
+                basePosition: t.bottomCenter
+              },
+              {
+                id: "bottom",
+                handlePosition: t.bottomCenter,
+                basePosition: t.topCenter
+              }
+            ];
+          },
+          scaleCallback: (t) => {
+            const { intersectPoint: o, scalePosition: n } = t, { id: s } = n, { cylinderMesh: r } = e;
+            s === "top" ? r.setTopCenter(o) : s === "bottom" && r.setBottomCenter(o);
+          }
+        }
+      };
+    });
+  }
+}
+export {
+  d as CylinderEditor
+};

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

@@ -0,0 +1,30 @@
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { CircleStyle } from '../../Meshes/Circle';
+import { CylinderMesh, type CylinderData } from '../../Meshes/Cylinder';
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { LiteralString } from '../../typings/utils.type';
+type CylinderStyle = CircleStyle;
+export interface CylinderImportData extends BaseImportData, CylinderData {
+    type: LiteralString<'Cylinder'>;
+    style?: Partial<CylinderStyle>;
+}
+export declare class Cylinder extends BaseObject<CylinderImportData> {
+    readonly type = "Cylinder";
+    cylinderMesh: CylinderMesh;
+    get data(): {
+        bottomCenter: [number, number, number];
+        topCenter: [number, number, number];
+        radius: number;
+        style: {
+            color: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: CylinderImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<CylinderStyle>): Promise<void>;
+}
+export declare function createCylinder(cylinderMesh: CylinderMesh, pointSelector: PointSelector): Promise<void>;
+export {};

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

@@ -0,0 +1,100 @@
+var L = Object.defineProperty, j = Object.defineProperties;
+var T = Object.getOwnPropertyDescriptors;
+var g = Object.getOwnPropertySymbols;
+var A = Object.prototype.hasOwnProperty, U = Object.prototype.propertyIsEnumerable;
+var p = (n, t, e) => t in n ? L(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, m = (n, t) => {
+  for (var e in t || (t = {}))
+    A.call(t, e) && p(n, e, t[e]);
+  if (g)
+    for (var e of g(t))
+      U.call(t, e) && p(n, e, t[e]);
+  return n;
+}, M = (n, t) => j(n, T(t));
+var y = (n, t, e) => (p(n, typeof t != "symbol" ? t + "" : t, e), e);
+var f = (n, t, e) => new Promise((r, s) => {
+  var c = (o) => {
+    try {
+      i(e.next(o));
+    } catch (a) {
+      s(a);
+    }
+  }, h = (o) => {
+    try {
+      i(e.throw(o));
+    } catch (a) {
+      s(a);
+    }
+  }, i = (o) => o.done ? r(o.value) : Promise.resolve(o.value).then(c, h);
+  i((e = e.apply(n, t)).next());
+});
+import { Sculpt as W } from "../../index.js";
+import { CylinderMesh as v } from "../../Meshes/Cylinder.js";
+import { LineMesh as z } from "../../Meshes/Line.js";
+import { rayOnLine as B } from "../../utils/three/rayOnLine.js";
+import { BaseObject as D } from "../Base/index.js";
+import { createCircle as F } from "../Circle/index.js";
+import * as b from "three";
+import { CylinderEditor as N } from "./Editor.js";
+import { vector3ToArray as O } from "../../../shared-utils/three/vector3ToArray.js";
+class Z extends D {
+  constructor(e, r) {
+    super(e, r);
+    y(this, "type", "Cylinder");
+    y(this, "cylinderMesh");
+    this.editor = new N(this), e && (this.cylinderMesh = new v(m(m({}, e.style), e)), this.add(this.cylinderMesh));
+  }
+  get data() {
+    return M(m({}, this.baseData), {
+      bottomCenter: O(this.applyObjectMatrixWorld(this.cylinderMesh.bottomCenter)),
+      topCenter: O(this.applyObjectMatrixWorld(this.cylinderMesh.topCenter)),
+      radius: this.cylinderMesh.radius,
+      style: {
+        color: this.cylinderMesh.color.getHex()
+      }
+    });
+  }
+  highlight() {
+    var e;
+    (e = this.cylinderMesh) == null || e.highlight();
+  }
+  unhighlight() {
+    var e;
+    (e = this.cylinderMesh) == null || e.unhighlight();
+  }
+  create(e) {
+    return f(this, null, function* () {
+      this.cylinderMesh = new v(e), this.add(this.cylinderMesh), yield R(this.cylinderMesh, this.pointSelector), this.editor.enable();
+    });
+  }
+}
+function R(n, t) {
+  return f(this, null, function* () {
+    const e = n.parent;
+    yield F(n.bottomCircle, t);
+    const r = new z();
+    r.name = "LineHelper", e.add(r);
+    const s = t.position.point, c = n.normal.clone().normalize(), h = s.clone().add(c.clone().multiplyScalar(10)), i = s.clone().sub(c.clone().multiplyScalar(10));
+    return r.setPoints([h, i]), t.enable(), new Promise((o, a) => {
+      const C = (l) => {
+        w(), o();
+      }, u = (l) => {
+        if (!(l != null && l.raycaster))
+          return;
+        const d = B(
+          W.modules.five.camera.position,
+          l.raycaster.ray,
+          new b.Line3(h, i)
+        ), x = new b.Plane().setFromNormalAndCoplanarPoint(n.normal, n.bottomCenter).projectPoint(d, new b.Vector3()), E = d.clone().sub(x), H = n.bottomCenter.clone().add(E);
+        d && n.setTopCenter(H);
+      }, w = () => {
+        t.off("select", C), t.off("intersectionUpdate", u), t.off("disable", P), e.remove(r), t.disable();
+      }, P = () => {
+        w(), e.remove(n), a(new Error("Cancelled"));
+      };
+      t.on("select", C), t.on("intersectionUpdate", u), t.on("disable", P);
+    });
+  });
+}
+export {
+  Z as Cylinder
+};

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

@@ -0,0 +1,8 @@
+import { BaseEditor } from '../Base/Editor';
+import type { Point } from '.';
+export declare class PointEditor extends BaseEditor<Point> {
+    constructor(originObject: Point);
+    enable(): void;
+    disable(): void;
+    private onDrag;
+}

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

@@ -0,0 +1,25 @@
+var n = Object.defineProperty;
+var a = (r, t, i) => t in r ? n(r, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : r[t] = i;
+var o = (r, t, i) => (a(r, typeof t != "symbol" ? t + "" : t, i), i);
+import { BaseEditor as c } from "../Base/Editor.js";
+import { Sculpt as g } from "../../index.js";
+import { getIntersectByRaycaster as b } from "../../../shared-utils/five/getPosition.js";
+class l extends c {
+  constructor(i) {
+    super(i);
+    o(this, "onDrag", (i) => {
+      var e;
+      const s = b(g.modules.five, i.raycaster);
+      (e = this.originObject.pointMesh) == null || e.position.copy(s.point);
+    });
+  }
+  enable() {
+    super.enable(), this.originObject.config.canEdit && (this.originObject.draggable = !0, this.originObject.on("drag", this.onDrag));
+  }
+  disable() {
+    super.disable(), this.originObject.config.canEdit && (this.originObject.draggable = !1, this.originObject.off("drag", this.onDrag));
+  }
+}
+export {
+  l as PointEditor
+};

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

@@ -0,0 +1,35 @@
+import { PointMesh, type PointData, type PointStyle } from '../../Meshes/Point';
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { LiteralString } from '../../typings/utils.type';
+export interface PointImportData extends BaseImportData, PointData {
+    type: LiteralString<'Point'>;
+    style?: Partial<PointStyle>;
+}
+export declare class Point extends BaseObject<PointImportData> {
+    readonly type = "Point";
+    pointMesh: PointMesh;
+    get data(): {
+        point: [number, number, number];
+        style: {
+            color: number;
+            size: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: PointImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    /**
+     * @description: 设置颜色
+     * @param {Color} style.color
+     * @param {number} style.size
+     */
+    setStyle(style: Partial<PointStyle>): void;
+    /**
+     * @description: 创建点
+     */
+    create(params?: PointStyle): Promise<void>;
+}
+export declare function createPoint(pointMesh: PointMesh, pointSelector: PointSelector): Promise<void>;

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

@@ -0,0 +1,92 @@
+var y = Object.defineProperty, b = Object.defineProperties;
+var u = Object.getOwnPropertyDescriptors;
+var m = Object.getOwnPropertySymbols;
+var w = Object.prototype.hasOwnProperty, P = Object.prototype.propertyIsEnumerable;
+var a = (e, i, t) => i in e ? y(e, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[i] = t, n = (e, i) => {
+  for (var t in i || (i = {}))
+    w.call(i, t) && a(e, t, i[t]);
+  if (m)
+    for (var t of m(i))
+      P.call(i, t) && a(e, t, i[t]);
+  return e;
+}, g = (e, i) => b(e, u(i));
+var M = (e, i, t) => (a(e, typeof i != "symbol" ? i + "" : i, t), t);
+var d = (e, i, t) => new Promise((o, h) => {
+  var r = (s) => {
+    try {
+      l(t.next(s));
+    } catch (c) {
+      h(c);
+    }
+  }, p = (s) => {
+    try {
+      l(t.throw(s));
+    } catch (c) {
+      h(c);
+    }
+  }, l = (s) => s.done ? o(s.value) : Promise.resolve(s.value).then(r, p);
+  l((t = t.apply(e, i)).next());
+});
+import { PointMesh as f } from "../../Meshes/Point.js";
+import { BaseObject as x } from "../Base/index.js";
+import { hotkeys as j } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { PointEditor as v } from "./Editor.js";
+import { vector3ToArray as z } from "../../../shared-utils/three/vector3ToArray.js";
+class H extends x {
+  constructor(t, o) {
+    super(t, o);
+    M(this, "type", "Point");
+    M(this, "pointMesh");
+    this.editor = new v(this), t && (this.pointMesh = new f(n(n({}, t.style), t)), this.add(this.pointMesh)), j("esc", () => {
+      this.stopCreating();
+    });
+  }
+  get data() {
+    return g(n({}, this.baseData), {
+      point: z(this.applyObjectMatrixWorld(this.pointMesh.position)),
+      style: {
+        color: this.pointMesh.color.getHex(),
+        size: this.pointMesh.size
+      }
+    });
+  }
+  highlight() {
+    var t;
+    (t = this.pointMesh) == null || t.highlight();
+  }
+  unhighlight() {
+    var t;
+    (t = this.pointMesh) == null || t.unhighlight();
+  }
+  /**
+   * @description: 设置颜色
+   * @param {Color} style.color
+   * @param {number} style.size
+   */
+  setStyle(t) {
+    this.pointMesh.setStyle(t);
+  }
+  /**
+   * @description: 创建点
+   */
+  create(t) {
+    return d(this, null, function* () {
+      this.pointMesh && this.remove(this.pointMesh), this.add(this.pointMesh = new f(t)), yield C(this.pointMesh, this.pointSelector), this.editor.enable();
+    });
+  }
+}
+function C(e, i) {
+  return new Promise((t, o) => {
+    i.enable();
+    const h = (r) => {
+      const { point: p } = r;
+      e.position.copy(p), t(), i.disable();
+    };
+    i.on("disable", () => {
+      i.off("select", h), o(new Error("Cancelled"));
+    }), i.once("select", h);
+  });
+}
+export {
+  H as Point
+};

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

@@ -0,0 +1,8 @@
+import type { Polygon } from '.';
+import type { FiveDomEvent } from '../../../shared-utils/five/FiveDomEvents';
+import { LineEditor } from '../Polyline/Editor';
+export declare class PolygonEditor extends LineEditor<Polygon> {
+    get lines(): import("../../Meshes/LineWithDots").LineWithDotsMesh[];
+    constructor(originObject: Polygon);
+    protected onDrag: (event: FiveDomEvent) => void;
+}

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

@@ -0,0 +1,23 @@
+var a = Object.defineProperty;
+var g = (o, i, t) => i in o ? a(o, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[i] = t;
+var r = (o, i, t) => (g(o, typeof i != "symbol" ? i + "" : i, t), t);
+import { Sculpt as c } from "../../index.js";
+import { getIntersectByRaycaster as p } from "../../../shared-utils/five/getPosition.js";
+import { LineEditor as h } from "../Polyline/Editor.js";
+class f extends h {
+  constructor(t) {
+    super(t);
+    r(this, "onDrag", (t) => {
+      if (!this.draggingPoints || this.draggingPoints.length === 0)
+        return;
+      const e = p(c.modules.five, t.raycaster), n = this.originObject.areaMesh.projectPoint(e.point);
+      this.draggingPoints.forEach((s) => s.position.copy(n)), this.originObject.areaMesh.setPoints(this.points.map((s) => s.position));
+    });
+  }
+  get lines() {
+    return this.originObject.areaMesh.lines;
+  }
+}
+export {
+  f as PolygonEditor
+};

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

@@ -0,0 +1,28 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import { AreaMesh, type AreaStyle } from '../../Meshes/Area';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { LiteralString } from '../../typings/utils.type';
+import type { PolygonData, PolygonStyle } from '../../Meshes/Polygon';
+export interface PolygonImportData extends BaseImportData, PolygonData {
+    type: LiteralString<'Polygon'>;
+    style?: Partial<AreaStyle>;
+}
+export declare class Polygon extends BaseObject<PolygonImportData> {
+    readonly type = "Polygon";
+    areaMesh: AreaMesh;
+    get data(): {
+        points: [number, number, number][];
+        style: {
+            color: number;
+            lineColor: number;
+            lineWidth: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: PolygonImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<PolygonStyle>): Promise<void>;
+}
+export declare function createPolygon(areaMesh: AreaMesh, pointSelector: PointSelector): Promise<void>;