@tscircuit/core 0.0.579 → 0.0.580

package/dist/index.js

@@ -4683,45 +4683,56 @@ var createSchematicTraceCrossingSegments = ({
 };
 
 // lib/components/primitive-components/Trace/trace-utils/create-schematic-trace-junctions.ts
+var TOLERANCE = 1e-3;
+var isPointWithinEdge = (point, edge) => {
+  const minX = Math.min(edge.from.x, edge.to.x);
+  const maxX = Math.max(edge.from.x, edge.to.x);
+  const minY = Math.min(edge.from.y, edge.to.y);
+  const maxY = Math.max(edge.from.y, edge.to.y);
+  return point.x >= minX && point.x <= maxX && point.y >= minY && point.y <= maxY;
+};
+var getEdgeOrientation = (edge) => {
+  const isVertical = Math.abs(edge.from.x - edge.to.x) < TOLERANCE;
+  const isHorizontal = Math.abs(edge.from.y - edge.to.y) < TOLERANCE;
+  if (isVertical) return "vertical";
+  if (isHorizontal) return "horizontal";
+  return "diagonal";
+};
 var getIntersectionPoint = (edge1, edge2) => {
-  if (edge1.from.x === edge1.to.x && edge2.from.x === edge2.to.x) {
+  const orientation1 = getEdgeOrientation(edge1);
+  const orientation2 = getEdgeOrientation(edge2);
+  if (orientation1 === orientation2) {
     return null;
   }
-  if (edge1.from.x === edge1.to.x) {
-    const x2 = edge1.from.x;
-    const m22 = (edge2.to.y - edge2.from.y) / (edge2.to.x - edge2.from.x);
-    const b22 = edge2.from.y - m22 * edge2.from.x;
-    const y2 = m22 * x2 + b22;
-    if (x2 >= Math.min(edge2.from.x, edge2.to.x) && x2 <= Math.max(edge2.from.x, edge2.to.x) && y2 >= Math.min(edge2.from.y, edge2.to.y) && y2 <= Math.max(edge2.from.y, edge2.to.y)) {
-      return { x: x2, y: y2 };
-    }
-    return null;
-  }
-  if (edge2.from.x === edge2.to.x) {
-    const x2 = edge2.from.x;
-    const m12 = (edge1.to.y - edge1.from.y) / (edge1.to.x - edge1.from.x);
-    const b12 = edge1.from.y - m12 * edge1.from.x;
-    const y2 = m12 * x2 + b12;
-    if (x2 >= Math.min(edge1.from.x, edge1.to.x) && x2 <= Math.max(edge1.from.x, edge1.to.x) && y2 >= Math.min(edge1.from.y, edge1.to.y) && y2 <= Math.max(edge1.from.y, edge1.to.y)) {
-      return { x: x2, y: y2 };
-    }
-    return null;
+  if (orientation1 === "vertical" && orientation2 === "horizontal" || orientation1 === "horizontal" && orientation2 === "vertical") {
+    const verticalEdge = orientation1 === "vertical" ? edge1 : edge2;
+    const horizontalEdge = orientation1 === "horizontal" ? edge1 : edge2;
+    const x2 = verticalEdge.from.x;
+    const y2 = horizontalEdge.from.y;
+    const intersection2 = { x: x2, y: y2 };
+    return isPointWithinEdge(intersection2, edge1) && isPointWithinEdge(intersection2, edge2) ? intersection2 : null;
+  }
+  if (orientation1 === "vertical" || orientation2 === "vertical") {
+    const verticalEdge = orientation1 === "vertical" ? edge1 : edge2;
+    const diagonalEdge = orientation1 === "vertical" ? edge2 : edge1;
+    const x2 = verticalEdge.from.x;
+    const m = (diagonalEdge.to.y - diagonalEdge.from.y) / (diagonalEdge.to.x - diagonalEdge.from.x);
+    const b = diagonalEdge.from.y - m * diagonalEdge.from.x;
+    const y2 = m * x2 + b;
+    const intersection2 = { x: x2, y: y2 };
+    return isPointWithinEdge(intersection2, edge1) && isPointWithinEdge(intersection2, edge2) ? intersection2 : null;
   }
   const m1 = (edge1.to.y - edge1.from.y) / (edge1.to.x - edge1.from.x);
   const b1 = edge1.from.y - m1 * edge1.from.x;
   const m2 = (edge2.to.y - edge2.from.y) / (edge2.to.x - edge2.from.x);
   const b2 = edge2.from.y - m2 * edge2.from.x;
-  if (m1 === m2) {
+  if (Math.abs(m1 - m2) < TOLERANCE) {
     return null;
   }
   const x = (b2 - b1) / (m1 - m2);
   const y = m1 * x + b1;
-  const isWithinEdge1 = x >= Math.min(edge1.from.x, edge1.to.x) && x <= Math.max(edge1.from.x, edge1.to.x) && y >= Math.min(edge1.from.y, edge1.to.y) && y <= Math.max(edge1.from.y, edge1.to.y);
-  const isWithinEdge2 = x >= Math.min(edge2.from.x, edge2.to.x) && x <= Math.max(edge2.from.x, edge2.to.x) && y >= Math.min(edge2.from.y, edge2.to.y) && y <= Math.max(edge2.from.y, edge2.to.y);
-  if (isWithinEdge1 && isWithinEdge2) {
-    return { x, y };
-  }
-  return null;
+  const intersection = { x, y };
+  return isPointWithinEdge(intersection, edge1) && isPointWithinEdge(intersection, edge2) ? intersection : null;
 };
 var createSchematicTraceJunctions = ({
   edges: myEdges,
@@ -4733,17 +4744,19 @@ var createSchematicTraceJunctions = ({
     source_trace_id,
     sameNetOnly: true
   }).flatMap((t) => t.edges);
-  const junctions = /* @__PURE__ */ new Set();
+  const junctions = /* @__PURE__ */ new Map();
   for (const myEdge of myEdges) {
     for (const otherEdge of otherEdges) {
       const intersection = getIntersectionPoint(myEdge, otherEdge);
       if (intersection) {
-        const pointKey = `${intersection.x},${intersection.y}`;
-        return [{ x: intersection.x, y: intersection.y }];
+        const key = `${intersection.x.toFixed(6)},${intersection.y.toFixed(6)}`;
+        if (!junctions.has(key)) {
+          junctions.set(key, intersection);
+        }
       }
     }
   }
-  return [];
+  return Array.from(junctions.values());
 };
 
 // lib/components/primitive-components/Trace/trace-utils/get-obstacles-for-trace.ts
@@ -11103,7 +11116,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.578",
+  version: "0.0.579",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.579",
+  "version": "0.0.580",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",