@ccpc/snap 0.1.3

package/index.js

@@ -0,0 +1,917 @@
+import { GGroup as k, GPoint2d as w, GCurve2d as y, DebugUtil as D, GNODE_TYPE as v, GPolycurve as H, GPolygon as R } from "@ccpc/core";
+import { Plane as j, Ln2 as f, Vec2 as _, alg as L, CONST as P, Curve2 as W } from "@ccpc/math";
+var o = /* @__PURE__ */ ((a) => (a[a.InvalidType = -1] = "InvalidType", a[a.EndPoint = 0] = "EndPoint", a[a.Pole = 1] = "Pole", a[a.XPt = 2] = "XPt", a[a.MiddlePoint = 3] = "MiddlePoint", a[a.Center = 4] = "Center", a[a.PerpendicularPoint = 5] = "PerpendicularPoint", a[a.PointOnCurve = 6] = "PointOnCurve", a[a.ReferCurve = 7] = "ReferCurve", a[a.ExtensionPoint = 8] = "ExtensionPoint", a[a.VerticalToCurve = 9] = "VerticalToCurve", a[a.ParallelToCurve = 10] = "ParallelToCurve", a[a.ParallelToX = 11] = "ParallelToX", a[a.ParallelToY = 12] = "ParallelToY", a[a.ClosedLineParallelToX = 13] = "ClosedLineParallelToX", a[a.ClosedLineParallelToY = 14] = "ClosedLineParallelToY", a[a.PointOnFace = 15] = "PointOnFace", a[a.PointOnSnapPlane = 16] = "PointOnSnapPlane", a))(o || {}), M = /* @__PURE__ */ ((a) => (a.POINT = "point", a.CURVE = "curve", a.DIR = "dir", a))(M || {});
+class A {
+  constructor(e, n) {
+    this._snapHelpers = /* @__PURE__ */ new Map(), e && n && (this._snappableGNodes = e, this._cursorWorld = n);
+  }
+  get snappableGNodes() {
+    return this._snappableGNodes;
+  }
+  set snappableGNodes(e) {
+    this._snappableGNodes = e;
+  }
+  get cursorWorld() {
+    return this._cursorWorld;
+  }
+  set cursorWorld(e) {
+    this._cursorWorld = e;
+  }
+  get previousPoint() {
+    return this._previousPoint;
+  }
+  set previousPoint(e) {
+    this._previousPoint = e;
+  }
+  get previousLineDir() {
+    return this._previousLineDir;
+  }
+  set previousLineDir(e) {
+    this._previousLineDir = e;
+  }
+  get firstPoint() {
+    return this._firstPoint;
+  }
+  set firstPoint(e) {
+    this._firstPoint = e;
+  }
+  get snapSort() {
+    return this._snapSort;
+  }
+  /**
+   * Function used to determine the order of the elements.It is expected to return a negative
+   * value if first argument is less than second argument, zero if they're equal and a positive value otherwise.
+   */
+  set snapSort(e) {
+    this._snapSort = e;
+  }
+  /**
+   * 获取某类吸附辅助对象
+   */
+  getSnapHelpers(e) {
+    return this._snapHelpers.get(e);
+  }
+  /**
+   * 设置某类吸附辅助对象
+   */
+  setSnapHelpers(e, n) {
+    this._snapHelpers.set(e, n);
+  }
+  /**
+   * 添加吸附辅助对象
+   */
+  addSnapHelpers(e, n) {
+    if (n.length) {
+      if (this._snapHelpers.get(e)) {
+        n[0].isVector2() ? this._snapHelpers.get(e).push(...n) : this._snapHelpers.get(e).push(n);
+        return;
+      }
+      n[0].isVector2() ? this.setSnapHelpers(e, n) : this.setSnapHelpers(e, [n]);
+    }
+  }
+}
+class V {
+  constructor(e) {
+    this._snapType = e, this._snappedGNodes = [], this._snappedObjects = [];
+  }
+  getSnapType() {
+    return this._snapType;
+  }
+  setSnapType(e) {
+    this._snapType = e;
+  }
+  getSnappedGNodes() {
+    return this._snappedGNodes;
+  }
+  setSnappedGNodes(e) {
+    this._snappedGNodes = e;
+  }
+  addSnappedGNode(e) {
+    this._snappedGNodes.push(e);
+  }
+  addSnappedGNodes(e) {
+    this._snappedGNodes.push(...e);
+  }
+  getSnappedObjects() {
+    return this._snappedObjects;
+  }
+  setSnappedObjects(e) {
+    this._snappedObjects = e;
+  }
+  addSnappedObject(e) {
+    this._snappedObjects.push(e);
+  }
+  addSnappedObjects(e) {
+    this._snappedObjects.push(...e);
+  }
+  getSnapPrompt() {
+    throw new Error("method not implement");
+  }
+}
+class O extends V {
+  constructor(e, n, t, s, r) {
+    super(e), this._snappedPt = n, this._disToCursor = t, r && (this._anotherPt = r), s && (this._snappedDir = s);
+  }
+  get snappedPt() {
+    return this._snappedPt;
+  }
+  set snappedPt(e) {
+    this._snappedPt = e;
+  }
+  set snappedDir(e) {
+    this._snappedDir = e;
+  }
+  get snappedDir() {
+    return this._snappedDir;
+  }
+  set anotherSnapType(e) {
+    this._anotherSnapType = e;
+  }
+  get anotherSnapType() {
+    return this._anotherSnapType;
+  }
+  set disToCursor(e) {
+    this._disToCursor = e;
+  }
+  get disToCursor() {
+    return this._disToCursor;
+  }
+  // TODO待优化
+  getSnapPrompt() {
+    const e = new k();
+    if (this.getSnapType() === o.PointOnSnapPlane)
+      return e;
+    const n = j.XOY(), t = new w(n, this._snappedPt.clone());
+    switch (t.setStyle({
+      point: {
+        size: 8,
+        color: 16777215
+      }
+    }), e.addNode(t), this.getSnapType()) {
+      case o.ParallelToX:
+      case o.ClosedLineParallelToX: {
+        if (this._anotherPt) {
+          const s = new y(n, new f(this._anotherPt, this._snappedPt));
+          s.setStyle({
+            line: {
+              width: 2,
+              color: 16711680
+            }
+          }), e.addNode(s);
+        }
+        break;
+      }
+      case o.ParallelToY:
+      case o.ClosedLineParallelToY: {
+        if (this._anotherPt) {
+          const s = new y(n, new f(this._anotherPt, this._snappedPt));
+          s.setStyle({
+            line: {
+              width: 2,
+              color: 65280
+            }
+          }), e.addNode(s);
+        }
+        break;
+      }
+    }
+    return e;
+  }
+  getSnapPromptString() {
+    return ((n) => {
+      let t = "unknown";
+      switch (n) {
+        case o.EndPoint:
+          t = "端点";
+          break;
+        case o.Pole:
+          t = "极点";
+          break;
+        case o.XPt:
+          t = "交点";
+          break;
+        case o.MiddlePoint:
+          t = "中点";
+          break;
+        case o.Center:
+          t = "中心";
+          break;
+        case o.PerpendicularPoint:
+          t = "垂足";
+          break;
+        case o.PointOnCurve:
+          t = "边线";
+          break;
+        case o.ReferCurve:
+          t = "参考线";
+          break;
+        case o.ExtensionPoint:
+          t = "延长线";
+          break;
+        case o.VerticalToCurve:
+          t = "垂直于曲线";
+          break;
+        case o.ParallelToCurve:
+          t = "平行于曲线";
+          break;
+        case o.ParallelToX:
+          t = "平行X轴";
+          break;
+        case o.ParallelToY:
+          t = "平行Y轴";
+          break;
+        case o.ClosedLineParallelToX:
+          t = "平行X轴";
+          break;
+        case o.ClosedLineParallelToY:
+          t = "平行Y轴";
+          break;
+        case o.PointOnFace:
+          t = "在面上";
+          break;
+        case o.PointOnSnapPlane:
+          t = "";
+          break;
+      }
+      return t;
+    })(this.getSnapType());
+  }
+}
+class I {
+  constructor() {
+    this._currentIndex = -1, this._snapResults = [];
+  }
+  get snapResults() {
+    return this._snapResults;
+  }
+  addSnapResult(e) {
+    this._snapResults.push(e);
+  }
+  addSnapResults(e) {
+    this._snapResults.push(...e);
+  }
+  sort(e) {
+    if (this._snapResults.length < 2)
+      return;
+    if (e) {
+      this._snapResults.sort(e);
+      return;
+    }
+    const n = (s) => s.anotherSnapType !== void 0 ? Math.min(s.getSnapType(), s.anotherSnapType) : s.getSnapType(), t = this._snapResults.filter((s) => s instanceof O);
+    t.sort((s, r) => n(s) - n(r) || s.disToCursor - r.disToCursor), this._snapResults = [...t];
+  }
+  getCurrentSnap() {
+    if (!(this._snapResults.length < 1))
+      return this._snapResults[this.currentIndex];
+  }
+  get currentIndex() {
+    return this._currentIndex;
+  }
+  set currentIndex(e) {
+    D.assert(e < this._snapResults.length && e > -1, "index不合法", "wg", "2026-03-25"), this._currentIndex = e;
+  }
+}
+var X = /* @__PURE__ */ ((a) => (a[a.X = 0] = "X", a[a.Y = 1] = "Y", a))(X || {});
+class l {
+  static instance() {
+    return l._instance || (l._instance = new l()), l._instance;
+  }
+  constructor() {
+    this._snapTolerance = 15, this._isSnapOff = !1, this._pixelsPerUnit = 1, this._reset(!0);
+  }
+  /**
+   * 修改snapSetting前备份原来状态
+   */
+  backup() {
+    this._backup = {
+      snapTolerance: this._snapTolerance,
+      isSnapOff: this._isSnapOff,
+      canSnapEndPt: this._canSnapEndPt,
+      canSnapMidPt: this._canSnapMidPt,
+      canSnapCenter: this._canSnapCenter,
+      canSnapPerpendicularPoint: this._canSnapPerpendicularPoint,
+      canSnapExtensionPoint: this._canSnapExtensionPoint,
+      canSnapVertical: this._canSnapVertical,
+      canSnapParallelToX: this._canSnapParallelToX,
+      canSnapParallelToY: this._canSnapParallelToY,
+      canSnapClosedLineParallelToX: this._canSnapClosedLineParallelToX,
+      canSnapClosedLineParallelToY: this._canSnapClosedLineParallelToY,
+      canSnapPointOnCurve: this._canSnapPointOnCurve,
+      canSnapPointOnFace: this._canSnapPointOnFace,
+      canSnapHelperObject: this._canSnapHelperObject,
+      canSnapHelperDir: this._canSnapHelperDir
+    };
+  }
+  /**
+   * 恢复上次备份的snapSetting状态
+   */
+  restore() {
+    this._backup && (this._snapTolerance = this._backup.snapTolerance, this._isSnapOff = this._backup.isSnapOff, this._canSnapEndPt = this._backup.canSnapEndPt, this._canSnapMidPt = this._backup.canSnapMidPt, this._canSnapCenter = this._backup.canSnapCenter, this._canSnapPerpendicularPoint = this._backup.canSnapPerpendicularPoint, this._canSnapExtensionPoint = this._backup.canSnapExtensionPoint, this._canSnapVertical = this._backup.canSnapVertical, this._canSnapParallelToX = this._backup.canSnapParallelToX, this._canSnapParallelToY = this._backup.canSnapParallelToY, this._canSnapClosedLineParallelToX = this._backup.canSnapClosedLineParallelToX, this._canSnapClosedLineParallelToY = this._backup.canSnapClosedLineParallelToY, this._canSnapPointOnCurve = this._backup.canSnapPointOnCurve, this._canSnapPointOnFace = this._backup.canSnapPointOnFace, this._canSnapHelperObject = this._backup.canSnapHelperObject, this._canSnapHelperDir = this._backup.canSnapHelperDir, delete this._backup);
+  }
+  getSnapTol() {
+    return this._snapTolerance;
+  }
+  // 设置捕捉精度，屏幕像素值
+  setSnapTol(e) {
+    this._snapTolerance = e;
+  }
+  setPixelsPerUnit(e) {
+    this._pixelsPerUnit = e;
+  }
+  getPixelsPerUnit() {
+    return this._pixelsPerUnit;
+  }
+  getSnapTolInWorld() {
+    return this._pixelsPerUnit <= 0 ? this._snapTolerance : this._snapTolerance / this._pixelsPerUnit;
+  }
+  get isSnapOff() {
+    return this._isSnapOff;
+  }
+  set isSnapOff(e) {
+    this._isSnapOff = e;
+  }
+  allowAll() {
+    this._reset(!0);
+  }
+  disableAll() {
+    this._reset(!1);
+  }
+  get canSnapEndPt() {
+    return this._canSnapEndPt;
+  }
+  set canSnapEndPt(e) {
+    this._canSnapEndPt = e;
+  }
+  get canSnapMidPt() {
+    return this._canSnapMidPt;
+  }
+  set canSnapMidPt(e) {
+    this._canSnapMidPt = e;
+  }
+  get canSnapCenter() {
+    return this._canSnapCenter;
+  }
+  set canSnapCenter(e) {
+    this._canSnapCenter = e;
+  }
+  get canSnapPerpendicularPoint() {
+    return this._canSnapPerpendicularPoint;
+  }
+  set canSnapPerpendicularPoint(e) {
+    this._canSnapPerpendicularPoint = e;
+  }
+  get canSnapExtensionPoint() {
+    return this._canSnapExtensionPoint;
+  }
+  set canSnapExtensionPoint(e) {
+    this._canSnapExtensionPoint = e;
+  }
+  get canSnapVertical() {
+    return this._canSnapVertical;
+  }
+  set canSnapVertical(e) {
+    this._canSnapVertical = e;
+  }
+  get canSnapHelperObject() {
+    return this._canSnapHelperObject;
+  }
+  set canSnapHelperObject(e) {
+    this._canSnapHelperObject = e;
+  }
+  get canSnapHelperDir() {
+    return this._canSnapHelperDir;
+  }
+  set canSnapHelperDir(e) {
+    this._canSnapHelperDir = e;
+  }
+  getCanSnapParallelToAxis(e) {
+    switch (e) {
+      case 0:
+        return this._canSnapParallelToX;
+      case 1:
+        return this._canSnapParallelToY;
+      default:
+        D.warn(!1, "未定义类型", "wg", "2026-03-25");
+    }
+    return !1;
+  }
+  setCanSnapParallelToAxis(e, n) {
+    switch (e) {
+      case 0:
+        this._canSnapParallelToX = n;
+        return;
+      case 1:
+        this._canSnapParallelToY = n;
+        return;
+      default:
+        D.warn(!1, "未定义类型", "wg", "2026-03-25");
+    }
+  }
+  getCanSnapClosedLineParallelToAxis(e) {
+    switch (e) {
+      case 0:
+        return this._canSnapClosedLineParallelToX;
+      case 1:
+        return this._canSnapClosedLineParallelToY;
+      default:
+        D.warn(!1, "未定义类型", "wg", "2026-03-25");
+    }
+    return !1;
+  }
+  setCanSnapClosedLineParallelToAxis(e, n) {
+    switch (e) {
+      case 0:
+        this._canSnapClosedLineParallelToX = n;
+        return;
+      case 1:
+        this._canSnapClosedLineParallelToY = n;
+        return;
+      default:
+        D.warn(!1, "未定义类型", "wg", "2026-03-25");
+    }
+  }
+  get canSnapPointOnCurve() {
+    return this._canSnapPointOnCurve;
+  }
+  set canSnapPointOnCurve(e) {
+    this._canSnapPointOnCurve = e;
+  }
+  get canSnapPointOnFace() {
+    return this._canSnapPointOnFace;
+  }
+  set canSnapPointOnFace(e) {
+    this._canSnapPointOnFace = e;
+  }
+  _reset(e) {
+    this._canSnapEndPt = e, this._canSnapMidPt = e, this._canSnapCenter = e, this._canSnapPerpendicularPoint = e, this._canSnapExtensionPoint = e, this._canSnapVertical = e, this._canSnapParallelToX = e, this._canSnapParallelToY = e, this._canSnapClosedLineParallelToX = e, this._canSnapClosedLineParallelToY = e, this._canSnapPointOnCurve = e, this._canSnapPointOnFace = e, this._canSnapHelperObject = e, this._canSnapHelperDir = e;
+  }
+}
+class d {
+  /**
+   * 点吸附
+   */
+  static intersectPoint(e, n, t) {
+    const s = e.distanceTo(n), r = l.instance().getSnapTolInWorld();
+    if (!(s > r))
+      return new O(t, n.clone(), s);
+  }
+  /**
+   * 曲线吸附
+   */
+  static intersectCurve(e, n, t, s) {
+    const r = new _(), c = L.D.ptToCurve2d(e, n, r), p = l.instance().getSnapTolInWorld();
+    if (c > p)
+      return;
+    const i = new O(t, r.clone(), c, void 0, s);
+    return i.addSnappedObject(n), i;
+  }
+  static curveIntersectGNode(e, n) {
+    let t = [];
+    n.getType() === v.GCurve2d ? t = [n.geo] : (n.getType() === v.GPolycurve || n.getType() === v.GPolygon) && (t = n.geo.getAllCurves());
+    const s = [];
+    return t.forEach((r) => {
+      L.X.curve2ds(e, r).forEach((p) => {
+        s.push({
+          pt: p.point,
+          c: r
+        });
+      });
+    }), s;
+  }
+}
+class T {
+  /**
+   * 捕捉特征点
+   */
+  static snapGPoint(e, n) {
+    const t = [], s = n.geo.userData?.snapType ?? o.XPt, r = d.intersectPoint(e.cursorWorld, n.geo, s);
+    return r && (r.addSnappedGNode(n), t.push(r)), t;
+  }
+  /**
+   * 捕捉两条线的交点
+   */
+  static snapCurvesXPoint(e, n) {
+    const t = [], s = n.map((c) => ({
+      node: c,
+      curves: this._getNodeCurves(c)
+    })).filter((c) => c.curves.length > 0);
+    if (s.length < 2)
+      return t;
+    const r = s[0];
+    for (let c = 1; c < s.length; c++) {
+      const p = s[c];
+      for (const i of r.curves)
+        for (const u of p.curves) {
+          const h = L.X.curve2ds(i, u);
+          for (const b of h) {
+            const g = d.intersectPoint(
+              e.cursorWorld,
+              b.point,
+              o.XPt
+            );
+            g && (g.addSnappedGNode(r.node), g.addSnappedGNode(p.node), t.push(g));
+          }
+        }
+    }
+    return t.sort((c, p) => c.disToCursor - p.disToCursor);
+  }
+  /**
+   * 捕捉“端点”、“中点”
+   */
+  static snapCurveFeaturePoint(e, n) {
+    let t = [];
+    const s = this.snapEndOrMidPoint(e, n);
+    if (s.length > 0)
+      t = s;
+    else {
+      const r = this.snapPointOnCurve(e, n);
+      r.length > 0 && (t = r);
+    }
+    return t;
+  }
+  /**
+   * 捕捉参考线
+   */
+  static snapReferenceCurve(e) {
+    const n = [], t = e.getSnapHelpers(M.CURVE);
+    if (!t?.length || !l.instance().canSnapHelperObject)
+      return n;
+    const s = [];
+    for (const r of t)
+      Array.isArray(r) && r.length && !r[0].isVector2() && s.push(r);
+    for (const r of s)
+      for (const c of r) {
+        const p = c.userData?.snapType ?? o.ReferCurve, i = d.intersectCurve(e.cursorWorld, c, p);
+        if (i)
+          return n.push(i), n;
+      }
+    return n;
+  }
+  /**
+   * 捕捉参考点
+   */
+  static snapReferencePoint(e) {
+    const n = [], t = e.getSnapHelpers(M.POINT);
+    if (!t?.length || !l.instance().canSnapHelperObject)
+      return n;
+    const s = t.filter((r) => !Array.isArray(r));
+    for (const r of s) {
+      const c = r.userData?.snapType ?? o.XPt, p = d.intersectPoint(e.cursorWorld, r, c);
+      if (p)
+        return n.push(p), n;
+    }
+    return n;
+  }
+  /**
+   * 捕捉“端点”、“中点”
+   */
+  static snapEndOrMidPoint(e, n) {
+    const t = [], s = e.cursorWorld;
+    if (n instanceof y) {
+      const r = n.geo;
+      if (l.instance().canSnapEndPt) {
+        const c = r.getStartPt();
+        let p = d.intersectPoint(s, c, o.EndPoint);
+        p && (p.addSnappedGNode(n), t.push(p));
+        const i = r.getEndPt();
+        p = d.intersectPoint(s, i, o.EndPoint), p && (p.addSnappedGNode(n), t.push(p));
+      }
+      if (l.instance().canSnapMidPt) {
+        const c = r.getMidPt(), p = d.intersectPoint(s, c, o.MiddlePoint);
+        p && (p.addSnappedGNode(n), t.push(p));
+      }
+      return t.sort((c, p) => c.disToCursor - p.disToCursor);
+    }
+    if (n instanceof H) {
+      const r = n.geo.getAllCurves();
+      if (!r.length)
+        return t;
+      if (l.instance().canSnapEndPt) {
+        const c = r[0].getStartPt(), p = d.intersectPoint(s, c, o.EndPoint);
+        p && (p.addSnappedGNode(n), t.push(p));
+        const i = r[r.length - 1].getEndPt(), u = d.intersectPoint(s, i, o.EndPoint);
+        u && (u.addSnappedGNode(n), t.push(u));
+      }
+      if (l.instance().canSnapMidPt) {
+        const p = r[Math.floor(r.length / 2)].getMidPt(), i = d.intersectPoint(s, p, o.MiddlePoint);
+        i && (i.addSnappedGNode(n), t.push(i));
+      }
+    }
+    return t.sort((r, c) => r.disToCursor - c.disToCursor);
+  }
+  /**
+   * 线上的点
+   */
+  static snapPointOnCurve(e, n) {
+    const t = [];
+    if (!l.instance().canSnapPointOnCurve)
+      return t;
+    if (n instanceof y) {
+      const s = this._snapPtOnCurve(n.geo, e, n);
+      return s && t.push(s), t;
+    }
+    if (n instanceof H)
+      for (const s of n.geo.getAllCurves()) {
+        const r = this._snapPtOnCurve(s, e, n);
+        if (r)
+          return t.push(r), t;
+      }
+    return t;
+  }
+  /**
+   * 面上的点
+   */
+  static snapPointOnFace(e, n) {
+    const t = [];
+    if (!l.instance().canSnapPointOnFace || L.PJ.ptToPolygon(
+      e.cursorWorld,
+      n.geo,
+      l.instance().getSnapTolInWorld()
+    ) === L.PtLoopPJType.OUT)
+      return t;
+    const r = new O(o.PointOnFace, e.cursorWorld.clone(), 0);
+    return r.addSnappedGNode(n), t.push(r), t;
+  }
+  /**
+   * 捕捉和曲线的交点
+   */
+  static _snapPtOnCurve(e, n, t) {
+    const s = d.intersectCurve(n.cursorWorld, e, o.PointOnCurve);
+    if (s)
+      return s.addSnappedGNode(t), s;
+  }
+  static _getNodeCurves(e) {
+    return e instanceof y ? [e.geo] : e instanceof H || e instanceof R ? e.geo.getAllCurves() : [];
+  }
+}
+class m {
+  static snapDirection(e) {
+    const n = [], t = this.snapExtensionPoint(e);
+    t.length > 0 && n.push(...t);
+    const s = this.snapHelperDirections(e);
+    s.length > 0 && n.push(...s);
+    const r = this.snapVerticalDir(e);
+    r.length > 0 && n.push(...r);
+    const c = this.snapPointParallelToAxis(e);
+    c.length > 0 && n.push(...c);
+    const p = this.snapLastLineDir(e);
+    return p.length > 0 && n.push(...p), n;
+  }
+  /**
+   * 捕捉过上一个点的水平/竖直方向
+   */
+  static snapPointParallelToAxis(e) {
+    const n = [];
+    if (!e.previousPoint)
+      return n;
+    if (l.instance().getCanSnapParallelToAxis(X.X)) {
+      const t = new f(
+        e.previousPoint,
+        _.X(),
+        [-P.MODEL_MAX_LENGTH, P.MODEL_MAX_LENGTH]
+      ), s = d.intersectCurve(
+        e.cursorWorld,
+        t,
+        o.ParallelToX,
+        e.previousPoint
+      );
+      if (s)
+        return s.snappedDir = _.X(), [s];
+    }
+    if (l.instance().getCanSnapParallelToAxis(X.Y)) {
+      const t = new f(
+        e.previousPoint,
+        _.Y(),
+        [-P.MODEL_MAX_LENGTH, P.MODEL_MAX_LENGTH]
+      ), s = d.intersectCurve(
+        e.cursorWorld,
+        t,
+        o.ParallelToY,
+        e.previousPoint
+      );
+      if (s)
+        return s.snappedDir = _.Y(), [s];
+    }
+    return n;
+  }
+  /**
+   * 捕捉延长线上的点
+   */
+  static snapExtensionPoint(e) {
+    const n = [];
+    if (!l.instance().canSnapExtensionPoint || !e.previousPoint || !e.previousLineDir)
+      return n;
+    const t = new f(
+      e.previousPoint,
+      e.previousLineDir,
+      [-P.MODEL_MAX_LENGTH, P.MODEL_MAX_LENGTH]
+    ), s = d.intersectCurve(
+      e.cursorWorld,
+      t,
+      o.ExtensionPoint
+    );
+    return s ? (s.snappedDir = t.getDirection(), [s]) : n;
+  }
+  /**
+   * 捕捉参考方向
+   */
+  static snapHelperDirections(e) {
+    const n = [];
+    if (!l.instance().canSnapHelperDir || !e.previousPoint || !e.getSnapHelpers(M.DIR)?.length)
+      return n;
+    for (const t of e.getSnapHelpers(M.DIR)) {
+      const s = new f(
+        e.previousPoint,
+        t,
+        [-P.MODEL_MAX_LENGTH, P.MODEL_MAX_LENGTH]
+      ), r = d.intersectCurve(
+        e.cursorWorld,
+        s,
+        t.userData?.snapType || o.ParallelToCurve
+      );
+      if (r)
+        return r.snappedDir = s.getDirection(), r.addSnappedObject(t), [r];
+    }
+    return n;
+  }
+  /**
+   * 捕捉和上一个方向垂直的方向
+   */
+  static snapVerticalDir(e) {
+    if (!l.instance().canSnapVertical)
+      return [];
+    if (!e.previousPoint || !e.previousLineDir)
+      return [];
+    const n = new _(-e.previousLineDir.y, e.previousLineDir.x).normalize(), t = new f(
+      e.previousPoint,
+      n,
+      [-P.MODEL_MAX_LENGTH, P.MODEL_MAX_LENGTH]
+    ), s = d.intersectCurve(
+      e.cursorWorld,
+      t,
+      o.VerticalToCurve
+    );
+    return s ? (s.snappedDir = n, [s]) : [];
+  }
+  /**
+   * 连续画线时，捕捉第一点与当前鼠标点连线，与坐标轴平行情况
+   */
+  static snapLastLineDir(e) {
+    const n = [];
+    if (!e.firstPoint || !e.previousPoint || e.firstPoint.equals(e.previousPoint))
+      return n;
+    if (l.instance().getCanSnapClosedLineParallelToAxis(X.X)) {
+      const t = new f(
+        e.firstPoint,
+        _.X(),
+        [-P.MODEL_MAX_LENGTH, P.MODEL_MAX_LENGTH]
+      ), s = d.intersectCurve(
+        e.cursorWorld,
+        t,
+        o.ClosedLineParallelToX,
+        e.firstPoint
+      );
+      if (s)
+        return s.snappedDir = _.X(), [s];
+    }
+    if (l.instance().getCanSnapClosedLineParallelToAxis(X.Y)) {
+      const t = new f(
+        e.firstPoint,
+        _.Y(),
+        [-P.MODEL_MAX_LENGTH, P.MODEL_MAX_LENGTH]
+      ), s = d.intersectCurve(
+        e.cursorWorld,
+        t,
+        o.ClosedLineParallelToY,
+        e.firstPoint
+      );
+      if (s)
+        return s.snappedDir = _.Y(), [s];
+    }
+    return n;
+  }
+}
+class z {
+  /**
+   * 捕捉唯一入口方法
+   * @param snapContext 捕捉输入信息
+   * @returns 捕捉结果候选集合
+   */
+  static snap(e) {
+    D.assert(e, "snapContext不应该为空", "wg", "2026-03-25");
+    const n = new I();
+    if (l.instance().isSnapOff)
+      return n;
+    const t = e.snappableGNodes;
+    if (t[0] && t[0].canSnap) {
+      const h = t[0];
+      n.addSnapResults(this._snapGNode(h.getType(), e, h));
+    }
+    const s = T.snapReferencePoint(e);
+    n.addSnapResults(s);
+    const r = T.snapReferenceCurve(e);
+    n.addSnapResults(r);
+    const c = m.snapDirection(e);
+    n.addSnapResults(c);
+    const p = T.snapCurvesXPoint(e, t);
+    n.addSnapResults(p);
+    const i = this._combineSnaps(e, c.concat(r), n.snapResults);
+    if (n.addSnapResults(i), n.sort(e.snapSort), n.snapResults.length)
+      return n;
+    const u = new O(o.PointOnSnapPlane, e.cursorWorld.clone(), 0);
+    return n.addSnapResult(u), n.sort(e.snapSort), n;
+  }
+  static _snapGNode(e, n, t) {
+    let s = [];
+    switch (e) {
+      case v.GPoint2d:
+        s = T.snapGPoint(n, t);
+        break;
+      case v.GCurve2d:
+        s = T.snapCurveFeaturePoint(n, t);
+        break;
+      case v.GPolycurve:
+        s = T.snapCurveFeaturePoint(n, t);
+        break;
+      case v.GPolygon:
+        s = T.snapPointOnFace(n, t);
+        break;
+    }
+    return s;
+  }
+  static _combineIntersects(e, n, t) {
+    const s = [];
+    if (!n.length || !t.length)
+      return s;
+    const r = (i) => {
+      if (i instanceof O && i.snappedPt && i.snappedDir)
+        return new f(i.snappedPt, i.snappedDir, [-P.MODEL_MAX_LENGTH, P.MODEL_MAX_LENGTH]);
+      const u = i.getSnappedObjects().filter((h) => h instanceof W);
+      if (u.length === 1)
+        return u[0];
+    }, c = (i, u) => i instanceof f && u instanceof f && i.getDirection().isParallel(u.getDirection()), p = (i, u) => i.snappedDir !== void 0 && u instanceof f && i.snappedDir.isPerpendicular(u.getDirection());
+    for (const i of n) {
+      const u = r(i);
+      if (u)
+        for (const h of t) {
+          if (i === h)
+            continue;
+          const b = h.getSnapType();
+          switch (b) {
+            case o.PointOnCurve: {
+              const g = h.getSnappedGNodes();
+              if (g.length !== 1)
+                break;
+              const G = d.curveIntersectGNode(u, g[0]);
+              for (const C of G) {
+                const S = d.intersectPoint(
+                  e.cursorWorld,
+                  C.pt,
+                  b
+                );
+                !S || c(u, C.c) || (i.getSnapType() === o.VerticalToCurve && i.snappedDir && C.c instanceof f && i.snappedDir.isPerpendicular(C.c.getDirection()) && S.setSnapType(o.PerpendicularPoint), S.addSnappedGNodes([...i.getSnappedGNodes(), ...h.getSnappedGNodes()]), S.addSnappedObjects([...i.getSnappedObjects(), ...h.getSnappedObjects()]), S.anotherSnapType = i.getSnapType(), i.snappedDir && (S.snappedDir = i.snappedDir.clone()), s.push(S));
+              }
+              break;
+            }
+            default: {
+              const g = r(h);
+              if (!g || c(u, g))
+                break;
+              const G = L.X.curve2ds(u, g);
+              for (const C of G) {
+                const S = d.intersectPoint(
+                  e.cursorWorld,
+                  C.point,
+                  b
+                );
+                S && (S.addSnappedGNodes([...i.getSnappedGNodes(), ...h.getSnappedGNodes()]), S.addSnappedObjects([...i.getSnappedObjects(), ...h.getSnappedObjects()]), S.anotherSnapType = i.getSnapType(), i.snappedDir && (S.snappedDir = i.snappedDir.clone()), i.getSnapType() === o.VerticalToCurve && (!(h instanceof O) || !h.snappedDir) && p(i, g) && S.setSnapType(o.PerpendicularPoint), s.push(S));
+              }
+              break;
+            }
+          }
+        }
+    }
+    return s;
+  }
+  /**
+   * 组合捕捉结果
+   */
+  static _combineSnaps(e, n, t) {
+    const s = [];
+    return s.push(...this._combineIntersects(e, n, t)), s;
+  }
+}
+export {
+  M as EN_SNAP_HELP_OBJ,
+  o as EN_SNAP_TYPE,
+  X as EN_XY,
+  O as PtSnap,
+  I as SnapCandidates,
+  A as SnapContext,
+  m as SnapDirection,
+  z as SnapEngine,
+  T as SnapPoint,
+  V as SnapResult,
+  l as SnapSetting,
+  d as SnapUtil
+};