circuit-to-svg 0.0.121 → 0.0.123

package/dist/index.js

@@ -18,7 +18,62 @@ function createSvgObjectsFromPcbTraceError(pcbTraceError, transform, circuitJson
   const port2 = circuitJson.find(
     (el) => el.type === "pcb_port" && el.pcb_port_id === pcb_port_ids?.[1]
   );
-  if (!port1 || !port2) return [];
+  if (!port1 || !port2) {
+    const viaIdMatch = pcbTraceError.message?.match(
+      /pcb_via\[#?(pcb_via_\d+)\]/
+    );
+    const viaId = viaIdMatch?.[1];
+    const via = circuitJson.find(
+      (el) => el.type === "pcb_via" && el.pcb_via_id === viaId
+    );
+    if (via && via.type === "pcb_via") {
+      return createSvgObjectsForViaTraceError(pcbTraceError, via, transform);
+    }
+    if (pcbTraceError.center) {
+      const screenCenter = applyToPoint(transform, {
+        x: pcbTraceError.center.x,
+        y: pcbTraceError.center.y
+      });
+      return [
+        {
+          name: "rect",
+          type: "element",
+          attributes: {
+            x: (screenCenter.x - 5).toString(),
+            y: (screenCenter.y - 5).toString(),
+            width: "10",
+            height: "10",
+            fill: "red",
+            transform: `rotate(45 ${screenCenter.x} ${screenCenter.y})`
+          },
+          children: [],
+          value: ""
+        },
+        {
+          name: "text",
+          type: "element",
+          attributes: {
+            x: screenCenter.x.toString(),
+            y: (screenCenter.y - 15).toString(),
+            fill: "red",
+            "font-family": "sans-serif",
+            "font-size": "12",
+            "text-anchor": "middle"
+          },
+          children: [
+            {
+              type: "text",
+              value: pcbTraceError.message || "Pcb Trace Error",
+              name: "",
+              attributes: {},
+              children: []
+            }
+          ],
+          value: ""
+        }
+      ];
+    } else return [];
+  }
   const screenPort1 = applyToPoint(transform, {
     x: port1.x,
     y: port1.y
@@ -104,6 +159,86 @@ function createSvgObjectsFromPcbTraceError(pcbTraceError, transform, circuitJson
   ];
   return svgObjects;
 }
+function createSvgObjectsForViaTraceError(pcbTraceError, via, transform) {
+  if (pcbTraceError.center && via) {
+    const screenCenter = applyToPoint(transform, {
+      x: pcbTraceError.center.x,
+      y: pcbTraceError.center.y
+    });
+    const screenVia = applyToPoint(transform, {
+      x: via.x,
+      y: via.y
+    });
+    const dx = screenVia.x - screenCenter.x;
+    const dy = screenVia.y - screenCenter.y;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    const angle = Math.atan2(dy, dx) * 180 / Math.PI;
+    const margin = 10;
+    const boxWidth = dist + margin * 2;
+    const boxHeight = 20;
+    const midX = (screenCenter.x + screenVia.x) / 2;
+    const midY = (screenCenter.y + screenVia.y) / 2;
+    return [
+      // Rotated bounding box
+      {
+        name: "rect",
+        type: "element",
+        attributes: {
+          x: (midX - boxWidth / 2).toString(),
+          y: (midY - boxHeight / 2).toString(),
+          width: boxWidth.toString(),
+          height: boxHeight.toString(),
+          fill: "none",
+          stroke: "red",
+          "stroke-width": "1",
+          "stroke-dasharray": "3,2",
+          transform: `rotate(${angle} ${midX} ${midY})`
+        },
+        children: [],
+        value: ""
+      },
+      // Error diamond
+      {
+        name: "rect",
+        type: "element",
+        attributes: {
+          x: (midX - 5).toString(),
+          y: (midY - 5).toString(),
+          width: "10",
+          height: "10",
+          fill: "red",
+          transform: `rotate(45 ${midX} ${midY})`
+        },
+        children: [],
+        value: ""
+      },
+      // Error label
+      {
+        name: "text",
+        type: "element",
+        attributes: {
+          x: midX.toString(),
+          y: (midY - boxHeight / 2 - 5).toString(),
+          fill: "red",
+          "font-family": "sans-serif",
+          "font-size": "12",
+          "text-anchor": "middle"
+        },
+        children: [
+          {
+            type: "text",
+            value: pcbTraceError.message || "Pcb Trace Error",
+            name: "",
+            attributes: {},
+            children: []
+          }
+        ],
+        value: ""
+      }
+    ];
+  }
+  return [];
+}
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-fabrication-note-path.ts
 import { applyToPoint as applyToPoint2 } from "transformation-matrix";
@@ -1351,12 +1486,35 @@ var getSchScreenFontSize = (transform, textType) => {
 };
 
 // lib/assembly/svg-object-fns/create-svg-objects-from-assembly-component.ts
-function createSvgObjectsFromAssemblyComponent(component, transform, firstPin, name) {
-  const { center, width, height, rotation = 0, layer = "top" } = component;
+function createSvgObjectsFromAssemblyComponent(params, ctx) {
+  const { elm, portPosition, name, arePinsInterchangeable } = params;
+  const { transform } = ctx;
+  const { center, width, height, rotation = 0, layer = "top" } = elm;
+  if (!center || typeof width !== "number" || typeof height !== "number")
+    return null;
   const [x, y] = applyToPoint19(transform, [center.x, center.y]);
-  const [pinX, pinY] = applyToPoint19(transform, [firstPin.x, firstPin.y]);
+  const [pinX, pinY] = applyToPoint19(transform, [portPosition.x, portPosition.y]);
   const scaledWidth = width * Math.abs(transform.a);
   const scaledHeight = height * Math.abs(transform.d);
+  const isTopLayer = layer === "top";
+  const isPinTop = pinY > y;
+  const isPinLeft = pinX < x;
+  const children = [
+    createComponentPath(scaledWidth, scaledHeight, rotation, layer),
+    createComponentLabel(scaledWidth, scaledHeight, name ?? "", transform)
+  ];
+  if (!arePinsInterchangeable) {
+    children.push(
+      createPin1Indicator(
+        scaledWidth,
+        scaledHeight,
+        rotation,
+        layer,
+        isPinTop,
+        isPinLeft
+      )
+    );
+  }
   return {
     name: "g",
     type: "element",
@@ -1364,29 +1522,14 @@ function createSvgObjectsFromAssemblyComponent(component, transform, firstPin, n
     attributes: {
       transform: `translate(${x}, ${y}) scale(1, -1)`
     },
-    children: [
-      createComponentPath(
-        scaledWidth,
-        scaledHeight,
-        x,
-        y,
-        pinX,
-        pinY,
-        rotation,
-        layer
-      ),
-      createComponentLabel(scaledWidth, scaledHeight, name ?? "", transform)
-    ]
+    children
   };
 }
-function createComponentPath(scaledWidth, scaledHeight, centerX, centerY, pinX, pinY, rotation, layer) {
+function createComponentPath(scaledWidth, scaledHeight, rotation, layer) {
   const w = scaledWidth / 2;
   const h = scaledHeight / 2;
-  const cornerSize = Math.min(w, h) * 0.3;
-  const isTop = pinY > centerY;
-  const isLeft = pinX < centerX;
   const strokeWidth = 0.8;
-  const path = getComponentPathData(w, h, cornerSize, isTop, isLeft, rotation);
+  const path = getRectPathData(w, h, rotation);
   return {
     name: "path",
     type: "element",
@@ -1436,47 +1579,76 @@ function createComponentLabel(scaledWidth, scaledHeight, name, transform) {
     value: ""
   };
 }
-function getComponentPathData(w, h, cornerSize, isTop, isLeft, rotation) {
-  const rotatePoint = (x, y, angle) => {
-    const rad = Math.PI / 180 * angle;
-    const cos = Math.cos(rad);
-    const sin = Math.sin(rad);
-    return [x * cos - y * sin, x * sin + y * cos];
-  };
-  let corners;
-  if (isTop && isLeft) {
-    corners = [
-      [-w, -h + cornerSize],
-      [-w + cornerSize, -h],
-      [w, -h],
-      [w, h],
-      [-w, h]
-    ];
-  } else if (isTop && !isLeft) {
-    corners = [
+function createPin1Indicator(scaledWidth, scaledHeight, rotation, layer, isPinTop, isPinLeft) {
+  const w = scaledWidth / 2;
+  const h = scaledHeight / 2;
+  const indicatorSize = Math.min(w, h) * 0.5;
+  let points;
+  if (isPinTop && isPinLeft) {
+    points = [
       [-w, -h],
-      [w - cornerSize, -h],
-      [w, -h + cornerSize],
-      [w, h],
-      [-w, h]
+      // Corner point
+      [-w + indicatorSize, -h],
+      // Point along top edge
+      [-w, -h + indicatorSize]
+      // Point along left edge
     ];
-  } else if (!isTop && isLeft) {
-    corners = [
-      [-w, -h],
+  } else if (isPinTop && !isPinLeft) {
+    points = [
       [w, -h],
-      [w, h],
-      [-w + cornerSize, h],
-      [-w, h - cornerSize]
+      // Corner point
+      [w - indicatorSize, -h],
+      // Point along top edge
+      [w, -h + indicatorSize]
+      // Point along right edge
+    ];
+  } else if (!isPinTop && isPinLeft) {
+    points = [
+      [-w, h],
+      // Corner point
+      [-w + indicatorSize, h],
+      // Point along bottom edge
+      [-w, h - indicatorSize]
+      // Point along left edge
     ];
   } else {
-    corners = [
-      [-w, -h],
-      [w, -h],
-      [w, h - cornerSize],
-      [w - cornerSize, h],
-      [-w, h]
+    points = [
+      [w, h],
+      // Corner point
+      [w - indicatorSize, h],
+      // Point along bottom edge
+      [w, h - indicatorSize]
+      // Point along right edge
     ];
   }
+  const pointsString = points.map((p) => p.join(",")).join(" ");
+  return {
+    name: "polygon",
+    type: "element",
+    attributes: {
+      class: "assembly-pin1-indicator",
+      points: pointsString,
+      fill: "#333",
+      stroke: "none",
+      transform: `rotate(${-rotation})`
+    },
+    value: "",
+    children: []
+  };
+}
+function getRectPathData(w, h, rotation) {
+  const rotatePoint = (x, y, angle) => {
+    const rad = Math.PI / 180 * angle;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    return [x * cos - y * sin, x * sin + y * cos];
+  };
+  const corners = [
+    [-w, -h],
+    [w, -h],
+    [w, h],
+    [-w, h]
+  ];
   const rotatedCorners = corners.map(([x, y]) => rotatePoint(x, y, rotation));
   const path = rotatedCorners.map(([x, y], i) => i === 0 ? `M${x},${y}` : `L${x},${y}`).join(" ");
   return `${path} Z`;
@@ -1599,14 +1771,17 @@ function createSvgObjects2(elm, transform, soup) {
       const ports = su3(soup).pcb_port.list().filter((port) => port.pcb_component_id === elm.pcb_component_id);
       const firstPort = ports[0];
       if (sourceComponent && firstPort) {
-        return [
-          createSvgObjectsFromAssemblyComponent(
+        const arePinsInterchangeable = sourceComponent.are_pins_interchangeable;
+        const obj = createSvgObjectsFromAssemblyComponent(
+          {
             elm,
-            transform,
-            { x: firstPort.x, y: firstPort.y },
-            sourceComponent.name
-          )
-        ].filter(Boolean);
+            portPosition: { x: firstPort.x, y: firstPort.y },
+            name: sourceComponent.name,
+            arePinsInterchangeable
+          },
+          { transform }
+        );
+        return obj ? [obj] : [];
       }
       return [];
     }