@skillpet/circuit 0.6.1 → 0.6.3

package/dist/circuit.bundle.js

@@ -17738,29 +17738,56 @@ var Circuit = (() => {
     const p = mergeParamsFirstWins(el.userParams, el.elmParams, el.defaults, el.dwgParams);
     return p.color ?? "black";
   }
+  var EXCLUDED_ANCHORS = /* @__PURE__ */ new Set([
+    "xy",
+    "center",
+    "istart",
+    "iend",
+    "mid",
+    "label",
+    "vd",
+    "vs",
+    "n1",
+    "n2",
+    "n1a",
+    "n2a"
+  ]);
+  function isConnectionAnchor(name) {
+    return !EXCLUDED_ANCHORS.has(name);
+  }
+  function getConnectionAnchors(el) {
+    const pts = [];
+    for (const [name, pt] of Object.entries(el.absanchors)) {
+      if (isConnectionAnchor(name)) pts.push(pt);
+    }
+    return pts;
+  }
   function buildConnectionGraph(elements) {
     const edges = [];
     const seen = /* @__PURE__ */ new Set();
     const tol = 0.5;
     for (let i = 0; i < elements.length; i++) {
-      const fromEl = elements[i];
-      const fromEnd = fromEl.absanchors.end;
-      if (!fromEnd) continue;
-      for (let j = 0; j < elements.length; j++) {
-        if (i === j) continue;
-        const toEl = elements[j];
-        const toStart = toEl.absanchors.start;
-        if (!toStart) continue;
-        const dx = fromEnd.x - toStart.x;
-        const dy = fromEnd.y - toStart.y;
-        if (Math.hypot(dx, dy) > tol) continue;
-        const fromColor = resolveElementColor(fromEl);
-        const toColor = resolveElementColor(toEl);
-        if (colorsEqual(fromColor, toColor)) continue;
-        const key = `${i}|${j}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        edges.push({ fromEl, toEl, fromColor, toColor });
+      const elA = elements[i];
+      const colorA = resolveElementColor(elA);
+      const anchorsA = getConnectionAnchors(elA);
+      if (anchorsA.length === 0) continue;
+      for (let j = i + 1; j < elements.length; j++) {
+        const elB = elements[j];
+        const colorB = resolveElementColor(elB);
+        if (colorsEqual(colorA, colorB)) continue;
+        const anchorsB = getConnectionAnchors(elB);
+        if (anchorsB.length === 0) continue;
+        for (const pa of anchorsA) {
+          for (const pb of anchorsB) {
+            if (Math.hypot(pa.x - pb.x, pa.y - pb.y) > tol) continue;
+            const key = `${i}|${j}`;
+            if (seen.has(key)) continue;
+            seen.add(key);
+            edges.push({ elA, elB, colorA, colorB, junctionPt: pa });
+            break;
+          }
+          if (seen.has(`${i}|${j}`)) break;
+        }
       }
     }
     return edges;
@@ -17775,26 +17802,28 @@ var Circuit = (() => {
     const cleanups = [];
     let n = 0;
     for (const edge of edges) {
-      const lead2Seg = findLeadSegment(edge.fromEl, "lead2");
-      const lead1Seg = findLeadSegment(edge.toEl, "lead1");
-      if (!lead2Seg && !lead1Seg) continue;
-      if (lead2Seg?.gradientStrokeId && lead1Seg?.gradientStrokeId) continue;
+      const segA = findSegAtJunction(edge.elA, edge.junctionPt);
+      const segB = findSegAtJunction(edge.elB, edge.junctionPt);
+      if (!segA && !segB) continue;
+      if (segA?.gradientStrokeId && segB?.gradientStrokeId) continue;
       let gx1, gy1, gx2, gy2;
-      if (lead2Seg && lead1Seg) {
-        const from = segEndpointsSvg(edge.fromEl, lead2Seg, scale);
-        const to = segEndpointsSvg(edge.toEl, lead1Seg, scale);
-        gx1 = from.x1;
-        gy1 = from.y1;
-        gx2 = to.x2;
-        gy2 = to.y2;
-      } else if (lead2Seg) {
-        const c = segEndpointsSvg(edge.fromEl, lead2Seg, scale);
+      if (segA && segB) {
+        const a = segEndpointsSvg(edge.elA, segA, scale);
+        const b = segEndpointsSvg(edge.elB, segB, scale);
+        const aNear = nearFarSvg(edge.elA, segA, edge.junctionPt, scale);
+        const bNear = nearFarSvg(edge.elB, segB, edge.junctionPt, scale);
+        gx1 = aNear.farX;
+        gy1 = aNear.farY;
+        gx2 = bNear.farX;
+        gy2 = bNear.farY;
+      } else if (segA) {
+        const c = segEndpointsSvg(edge.elA, segA, scale);
         gx1 = c.x1;
         gy1 = c.y1;
         gx2 = c.x2;
         gy2 = c.y2;
       } else {
-        const c = segEndpointsSvg(edge.toEl, lead1Seg, scale);
+        const c = segEndpointsSvg(edge.elB, segB, scale);
         gx1 = c.x1;
         gy1 = c.y1;
         gx2 = c.x2;
@@ -17802,17 +17831,17 @@ var Circuit = (() => {
       }
       if (gradientVectorLength({ x1: gx1, y1: gy1, x2: gx2, y2: gy2 }) < 1e-6) continue;
       const id = `sd-trans-${n++}`;
-      parts.push(gradientXml(id, gx1, gy1, gx2, gy2, edge.fromColor, edge.toColor));
-      if (lead2Seg && !lead2Seg.gradientStrokeId) {
-        lead2Seg.gradientStrokeId = id;
+      parts.push(gradientXml(id, gx1, gy1, gx2, gy2, edge.colorA, edge.colorB));
+      if (segA && !segA.gradientStrokeId) {
+        segA.gradientStrokeId = id;
         cleanups.push(() => {
-          lead2Seg.gradientStrokeId = void 0;
+          segA.gradientStrokeId = void 0;
         });
       }
-      if (lead1Seg && !lead1Seg.gradientStrokeId) {
-        lead1Seg.gradientStrokeId = id;
+      if (segB && !segB.gradientStrokeId) {
+        segB.gradientStrokeId = id;
         cleanups.push(() => {
-          lead1Seg.gradientStrokeId = void 0;
+          segB.gradientStrokeId = void 0;
         });
       }
     }
@@ -17823,11 +17852,46 @@ var Circuit = (() => {
       }
     };
   }
-  function findLeadSegment(el, role) {
+  function findSegAtJunction(el, junctionPt) {
+    const tol = 0.6;
     for (const s of el.segments) {
-      if (s instanceof Segment && s.role === role) return s;
+      if (!(s instanceof Segment)) continue;
+      if (s.role !== "lead1" && s.role !== "lead2") continue;
+      if (segTouchesPoint(el, s, junctionPt, tol)) return s;
     }
-    return void 0;
+    let best;
+    let bestDist = Infinity;
+    for (const s of el.segments) {
+      if (!(s instanceof Segment)) continue;
+      if (s.path.length < 2) continue;
+      if (s.role === "body") continue;
+      if (s.path.length > 6) continue;
+      const d = segDistToPoint(el, s, junctionPt);
+      if (d < bestDist && d < tol) {
+        bestDist = d;
+        best = s;
+      }
+    }
+    return best;
+  }
+  function segTouchesPoint(el, seg, absPt, tol) {
+    return segDistToPoint(el, seg, absPt) < tol;
+  }
+  function segDistToPoint(el, seg, absPt) {
+    const p0 = el.transform.transform(seg.path[0]);
+    const pN = el.transform.transform(seg.path[seg.path.length - 1]);
+    return Math.min(
+      Math.hypot(p0.x - absPt.x, p0.y - absPt.y),
+      Math.hypot(pN.x - absPt.x, pN.y - absPt.y)
+    );
+  }
+  function nearFarSvg(el, seg, junctionPt, scale) {
+    const p0 = el.transform.transform(seg.path[0]);
+    const pN = el.transform.transform(seg.path[seg.path.length - 1]);
+    const d0 = Math.hypot(p0.x - junctionPt.x, p0.y - junctionPt.y);
+    const dN = Math.hypot(pN.x - junctionPt.x, pN.y - junctionPt.y);
+    const far = d0 > dN ? p0 : pN;
+    return { farX: far.x * scale, farY: -far.y * scale };
   }
   function segEndpointsSvg(el, seg, scale) {
     const p0 = el.transform.transform(seg.path[0]);