@tscircuit/core 0.0.1350 → 0.0.1351

package/dist/index.js

@@ -19796,6 +19796,111 @@ function computeJunctions(traces, opts = {}) {
   return result;
 }
 
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/remove-overlapping-same-net-crossing-segments.ts
+var TOL3 = 1e-6;
+function isCollinear(a, b, tol = TOL3) {
+  const adx = a.to.x - a.from.x;
+  const ady = a.to.y - a.from.y;
+  const bdx = b.to.x - b.from.x;
+  const bdy = b.to.y - b.from.y;
+  const aLen = Math.hypot(adx, ady);
+  const bLen = Math.hypot(bdx, bdy);
+  if (aLen <= tol || bLen <= tol) return false;
+  const directionCross = adx * bdy - ady * bdx;
+  if (Math.abs(directionCross) > tol * aLen * bLen) return false;
+  const offsetCross = adx * (b.from.y - a.from.y) - ady * (b.from.x - a.from.x);
+  return Math.abs(offsetCross) <= tol * aLen;
+}
+function splitEdgeAroundIntervals(edge, intervals) {
+  const merged = mergeIntervals(intervals);
+  if (merged.length === 0) return [edge];
+  const edgeLength = length6(edge.from, edge.to);
+  if (edgeLength <= TOL3) return [edge];
+  const result = [];
+  let cursor = 0;
+  for (const interval of merged) {
+    if (interval.start - cursor > TOL3) {
+      result.push({
+        from: pointAt(edge.from, edge.to, cursor / edgeLength),
+        to: pointAt(edge.from, edge.to, interval.start / edgeLength)
+      });
+    }
+    if (interval.end - interval.start > TOL3) {
+      result.push({
+        from: pointAt(edge.from, edge.to, interval.start / edgeLength),
+        to: pointAt(edge.from, edge.to, interval.end / edgeLength),
+        is_crossing: true
+      });
+    }
+    cursor = Math.max(cursor, interval.end);
+  }
+  if (edgeLength - cursor > TOL3) {
+    result.push({
+      from: pointAt(edge.from, edge.to, cursor / edgeLength),
+      to: edge.to
+    });
+  }
+  return result;
+}
+function removeOverlappingSameNetCrossingSegments(traces) {
+  const intervalsToRemove = /* @__PURE__ */ new Map();
+  for (let crossingTraceIndex = 0; crossingTraceIndex < traces.length; crossingTraceIndex++) {
+    const crossingTrace = traces[crossingTraceIndex];
+    if (!crossingTrace.connectivity_key) continue;
+    for (const crossingEdge of crossingTrace.edges) {
+      if (!crossingEdge.is_crossing || length6(crossingEdge.from, crossingEdge.to) <= TOL3)
+        continue;
+      for (let traceIndex = 0; traceIndex < traces.length; traceIndex++) {
+        const candidateTrace = traces[traceIndex];
+        if (traceIndex === crossingTraceIndex || candidateTrace.connectivity_key !== crossingTrace.connectivity_key) {
+          continue;
+        }
+        for (let edgeIndex = 0; edgeIndex < candidateTrace.edges.length; edgeIndex++) {
+          const candidateEdge = candidateTrace.edges[edgeIndex];
+          const candidateLength = length6(candidateEdge.from, candidateEdge.to);
+          if (candidateEdge.is_crossing || candidateLength <= TOL3) continue;
+          if (!isCollinear(candidateEdge, crossingEdge)) continue;
+          const start = Math.max(
+            0,
+            Math.min(
+              paramAlong(
+                candidateEdge.from,
+                candidateEdge.to,
+                crossingEdge.from
+              ),
+              paramAlong(candidateEdge.from, candidateEdge.to, crossingEdge.to)
+            )
+          );
+          const end = Math.min(
+            candidateLength,
+            Math.max(
+              paramAlong(
+                candidateEdge.from,
+                candidateEdge.to,
+                crossingEdge.from
+              ),
+              paramAlong(candidateEdge.from, candidateEdge.to, crossingEdge.to)
+            )
+          );
+          if (end - start <= TOL3) continue;
+          const key = `${traceIndex}:${edgeIndex}`;
+          const intervals = intervalsToRemove.get(key) ?? [];
+          intervals.push({ start, end });
+          intervalsToRemove.set(key, intervals);
+        }
+      }
+    }
+  }
+  if (intervalsToRemove.size === 0) return traces;
+  return traces.map((trace, traceIndex) => ({
+    ...trace,
+    edges: trace.edges.flatMap((edge, edgeIndex) => {
+      const intervals = intervalsToRemove.get(`${traceIndex}:${edgeIndex}`);
+      return intervals ? splitEdgeAroundIntervals(edge, intervals) : [edge];
+    })
+  }));
+}
+
 // lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/applyTracesFromSolverOutput.ts
 import Debug10 from "debug";
 var debug8 = Debug10("Group_doInitialSchematicTraceRender");
@@ -19950,19 +20055,37 @@ function applyTracesFromSolverOutput(args) {
   );
   const existingTracesForJunctions = [];
   for (const t of db.schematic_trace.list()) {
-    if (!t.source_trace_id || t.edges.length === 0) continue;
-    const sourceTrace = db.source_trace.get(t.source_trace_id);
+    if (t.edges.length === 0) continue;
+    const sourceTrace = t.source_trace_id ? db.source_trace.get(t.source_trace_id) : void 0;
     existingTracesForJunctions.push({
-      source_trace_id: t.source_trace_id,
+      schematic_trace_id: t.schematic_trace_id,
+      source_trace_id: t.source_trace_id ?? t.schematic_trace_id,
       edges: t.edges,
       connectivity_key: t.subcircuit_connectivity_map_key ?? sourceTrace?.subcircuit_connectivity_map_key
     });
   }
-  const junctionsById = computeJunctions([
+  const tracesWithTrimmedCrossingOverlaps = removeOverlappingSameNetCrossingSegments([
     ...withCrossings,
     ...existingTracesForJunctions
   ]);
-  for (const t of withCrossings) {
+  const visibleTraces = tracesWithTrimmedCrossingOverlaps.slice(
+    0,
+    withCrossings.length
+  );
+  const visibleExistingTraces = tracesWithTrimmedCrossingOverlaps.slice(
+    withCrossings.length
+  );
+  for (const trace of visibleExistingTraces) {
+    if (!trace.schematic_trace_id) continue;
+    db.schematic_trace.update(trace.schematic_trace_id, {
+      edges: trace.edges
+    });
+  }
+  const junctionsById = computeJunctions([
+    ...visibleTraces,
+    ...visibleExistingTraces
+  ]);
+  for (const t of visibleTraces) {
     db.schematic_trace.insert({
       source_trace_id: t.source_trace_id,
       edges: t.edges,
@@ -24065,7 +24188,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1349",
+  version: "0.0.1350",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -30330,7 +30453,7 @@ var SchematicSection = class _SchematicSection extends PrimitiveComponent2 {
     const PADDING = 0.5;
     const LABEL_PADDING = 0.2;
     const STROKE_WIDTH = 0.02;
-    const TOL3 = 1e-3;
+    const TOL4 = 1e-3;
     const namedSectionsWithBounds = allSections.map((section) => {
       const bounds = section._computeSectionBounds(
         board,
@@ -30387,10 +30510,10 @@ var SchematicSection = class _SchematicSection extends PrimitiveComponent2 {
       });
     }
     const hDividers = dividers.filter(
-      (l) => Math.abs(l.start.y - l.end.y) < TOL3
+      (l) => Math.abs(l.start.y - l.end.y) < TOL4
     );
     const vDividers = dividers.filter(
-      (l) => Math.abs(l.start.x - l.end.x) < TOL3
+      (l) => Math.abs(l.start.x - l.end.x) < TOL4
     );
     for (const {
       displayName,

package/package.json

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