@realsee/dnalogel 3.20.6 → 3.21.0

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>;

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

@@ -0,0 +1,113 @@
+var H = Object.defineProperty, T = Object.defineProperties;
+var j = Object.getOwnPropertyDescriptors;
+var b = Object.getOwnPropertySymbols;
+var A = Object.prototype.hasOwnProperty, D = Object.prototype.propertyIsEnumerable;
+var g = (i, t, e) => t in i ? H(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e, c = (i, t) => {
+  for (var e in t || (t = {}))
+    A.call(t, e) && g(i, e, t[e]);
+  if (b)
+    for (var e of b(t))
+      D.call(t, e) && g(i, e, t[e]);
+  return i;
+}, W = (i, t) => T(i, j(t));
+var m = (i, t, e) => (g(i, typeof t != "symbol" ? t + "" : t, e), e);
+var E = (i, t, e) => new Promise((r, s) => {
+  var d = (o) => {
+    try {
+      l(e.next(o));
+    } catch (a) {
+      s(a);
+    }
+  }, n = (o) => {
+    try {
+      l(e.throw(o));
+    } catch (a) {
+      s(a);
+    }
+  }, l = (o) => o.done ? r(o.value) : Promise.resolve(o.value).then(d, n);
+  l((e = e.apply(i, t)).next());
+});
+import { hotkeys as L } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { BaseObject as O } from "../Base/index.js";
+import { PolylineMesh as x } from "../../Meshes/Polyline.js";
+import { AreaMesh as M } from "../../Meshes/Area.js";
+import { PolygonEditor as U } from "./Editor.js";
+import { vector3ToArray as k } from "../../../shared-utils/three/vector3ToArray.js";
+class K extends O {
+  constructor(e, r) {
+    super(e, r);
+    m(this, "type", "Polygon");
+    m(this, "areaMesh");
+    this.editor = new U(this), e && (this.areaMesh = new M(c(c({}, e.style), e)), this.add(this.areaMesh)), L("esc", () => {
+      this.stopCreating();
+    });
+  }
+  get data() {
+    return W(c({}, this.baseData), {
+      points: k(this.applyObjectMatrixWorld(this.areaMesh.points)),
+      style: {
+        color: this.areaMesh.color.getHex(),
+        lineColor: this.areaMesh.lineColor.getHex(),
+        lineWidth: this.areaMesh.lineWidth
+      }
+    });
+  }
+  highlight() {
+    var e;
+    (e = this.areaMesh) == null || e.highlight();
+  }
+  unhighlight() {
+    var e;
+    (e = this.areaMesh) == null || e.unhighlight();
+  }
+  create(e) {
+    return E(this, null, function* () {
+      this.children.forEach((s) => {
+        s.parent === this && this.remove(s);
+      }), this.children.length = 0;
+      const r = new M(e);
+      this.areaMesh = r, this.add(this.areaMesh), yield B(this.areaMesh, this.pointSelector), this.editor.enable();
+    });
+  }
+}
+function B(i, t) {
+  return new Promise((e, r) => {
+    const s = i.parent;
+    if (!s) {
+      r(new Error("No container"));
+      return;
+    }
+    const d = new x({ dashed: !0, lineColor: i.lineColor, lineWidth: i.lineWidth });
+    s == null || s.add(d);
+    const n = new x({ dashed: !0, lineColor: i.lineColor, lineWidth: i.lineWidth });
+    s == null || s.add(n), t.enable();
+    const l = [];
+    let o, a = !1;
+    const u = (h) => {
+      const p = l.length === 0 ? h.point : o.clone();
+      l.push(p.clone()), i.setPoints(l, !1), a && (y(), e());
+    }, P = (h) => {
+      var v;
+      if (!((v = i.points) != null && v.length) || !h)
+        return;
+      const p = l.at(-1).clone();
+      if (i.points.length <= 2)
+        o = h.point, d.setPoints([p, o]), s != null && s.children.includes(n) && s.remove(n);
+      else {
+        o = i.projectPoint(h.point);
+        const f = i.points[0], C = 0.2;
+        f.distanceTo(o) < C || f.distanceTo(h.point) < C ? (o = f, h.point.copy(f), t.pointSelectorHelper.updateWithIntersect(h, { emitEvent: !1 }), a = !0) : a = !1, n.setPoints([o, h.point]), s != null && s.children.includes(n) || s == null || s.add(n);
+      }
+      d.setPoints([p, o]), l.length >= 2 && i.polygon.setPoints([...l, o]);
+    }, y = () => {
+      t.off("select", u), t.off("intersectionUpdate", P), t.off("disable", w), t.disable(), s == null || s.remove(d, n);
+    }, w = () => {
+      y(), s == null || s.remove(i, n, d), r(new Error("Cancelled"));
+    };
+    t.on("select", u), t.on("intersectionUpdate", P), t.on("disable", w);
+  });
+}
+export {
+  K as Polygon,
+  B as createPolygon
+};

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

@@ -0,0 +1,25 @@
+import { BaseEditor } from '../Base/Editor';
+import type { FiveDomEvent } from '../../../shared-utils/five/FiveDomEvents';
+import type { Polyline } from '.';
+import type * as THREE from 'three';
+import { PointMesh } from '../../Meshes/Point';
+import type { LineWithDotsMesh } from '../../Meshes/LineWithDots';
+export declare abstract class LineEditor<OriginObject extends THREE.Object3D = THREE.Object3D> extends BaseEditor<OriginObject> {
+    protected draggingPoints: PointMesh[];
+    protected get points(): PointMesh[];
+    abstract get lines(): LineWithDotsMesh[];
+    get pointHandles(): PointMesh[];
+    constructor(originObject: OriginObject);
+    enable(): void;
+    disable(): void;
+    protected onDragstart: (event: FiveDomEvent) => void;
+    protected onDragend: (event: FiveDomEvent) => void;
+    protected abstract onDrag(event: FiveDomEvent): void;
+}
+export declare class PolylineEditor extends LineEditor<Polyline> {
+    get lines(): LineWithDotsMesh[];
+    constructor(originObject: Polyline);
+    enable(): void;
+    disable(): void;
+    protected onDrag: (event: FiveDomEvent) => void;
+}