circuit-to-svg 0.0.89 → 0.0.91

package/dist/index.js

@@ -1281,6 +1281,8 @@ function getSchematicBoundsFromCircuitJson(soup, padding = 0.5) {
       }
     } else if (item.type === "schematic_text") {
       updateBounds(item.position, { width: 0.1, height: 0.1 }, 0);
+    } else if (item.type === "schematic_voltage_probe") {
+      updateBounds(item.position, { width: 0.2, height: 0.4 }, 0);
     }
   }
   minX -= padding;
@@ -1927,15 +1929,77 @@ function createSvgObjectsFromSchematicComponent(params) {
   ];
 }
 
-// lib/sch/svg-object-fns/create-svg-objects-from-sch-debug-object.ts
+// lib/sch/svg-object-fns/create-svg-objects-from-sch-voltage-probe.ts
 import { applyToPoint as applyToPoint23 } from "transformation-matrix";
+function createSvgObjectsFromSchVoltageProbe(probe, transform) {
+  const [screenX, screenY] = applyToPoint23(transform, [
+    probe.position.x,
+    probe.position.y
+  ]);
+  const arrowLength = Math.abs(transform.a) * 0.6;
+  const arrowWidth = Math.abs(transform.a) * 0.28;
+  const baseX = screenX + arrowLength * Math.cos(-50 * Math.PI / 180);
+  const baseY = screenY + arrowLength * Math.sin(-50 * Math.PI / 180);
+  const tipX = screenX;
+  const tipY = screenY;
+  const arrowPath = [
+    `M ${baseX},${baseY}`,
+    `L ${tipX},${tipY}`,
+    `M ${tipX},${tipY}`,
+    `L ${tipX - arrowWidth * Math.cos((-50 + 150) * Math.PI / 180)},${tipY - arrowWidth * Math.sin((-50 + 150) * Math.PI / 180)}`,
+    `L ${tipX - arrowWidth * Math.cos((-50 + 210) * Math.PI / 180)},${tipY - arrowWidth * Math.sin((-50 + 210) * Math.PI / 180)}`,
+    "Z"
+  ].join(" ");
+  return [
+    {
+      name: "path",
+      type: "element",
+      attributes: {
+        d: arrowPath,
+        stroke: colorMap.schematic.reference,
+        fill: colorMap.schematic.reference,
+        "stroke-width": `${getSchStrokeSize(transform)}px`
+      },
+      value: "",
+      children: []
+    },
+    {
+      type: "element",
+      name: "text",
+      value: "",
+      attributes: {
+        x: (baseX + 8 - (baseX - baseX)).toString(),
+        y: (baseY - 10 + (baseY - baseY)).toString(),
+        fill: colorMap.schematic.reference,
+        "text-anchor": "middle",
+        "dominant-baseline": "middle",
+        "font-family": "sans-serif",
+        "font-size": `${getSchScreenFontSize(transform, "reference_designator")}px`,
+        "font-weight": "bold",
+        "data-schematic-voltage-probe-id": probe.schematic_voltage_probe_id
+      },
+      children: [
+        {
+          type: "text",
+          value: probe.voltage ? `${probe.voltage}V` : "",
+          name: "",
+          attributes: {},
+          children: []
+        }
+      ]
+    }
+  ];
+}
+
+// lib/sch/svg-object-fns/create-svg-objects-from-sch-debug-object.ts
+import { applyToPoint as applyToPoint24 } from "transformation-matrix";
 function createSvgObjectsFromSchDebugObject(debugObject, transform) {
   if (debugObject.shape === "rect") {
-    let [screenLeft, screenTop] = applyToPoint23(transform, [
+    let [screenLeft, screenTop] = applyToPoint24(transform, [
       debugObject.center.x - debugObject.size.width / 2,
       debugObject.center.y - debugObject.size.height / 2
     ]);
-    let [screenRight, screenBottom] = applyToPoint23(transform, [
+    let [screenRight, screenBottom] = applyToPoint24(transform, [
       debugObject.center.x + debugObject.size.width / 2,
       debugObject.center.y + debugObject.size.height / 2
     ]);
@@ -1945,7 +2009,7 @@ function createSvgObjectsFromSchDebugObject(debugObject, transform) {
     ];
     const width = Math.abs(screenRight - screenLeft);
     const height = Math.abs(screenBottom - screenTop);
-    const [screenCenterX, screenCenterY] = applyToPoint23(transform, [
+    const [screenCenterX, screenCenterY] = applyToPoint24(transform, [
       debugObject.center.x,
       debugObject.center.y
     ]);
@@ -1991,11 +2055,11 @@ function createSvgObjectsFromSchDebugObject(debugObject, transform) {
     ];
   }
   if (debugObject.shape === "line") {
-    const [screenStartX, screenStartY] = applyToPoint23(transform, [
+    const [screenStartX, screenStartY] = applyToPoint24(transform, [
       debugObject.start.x,
       debugObject.start.y
     ]);
-    const [screenEndX, screenEndY] = applyToPoint23(transform, [
+    const [screenEndX, screenEndY] = applyToPoint24(transform, [
       debugObject.end.x,
       debugObject.end.y
     ]);
@@ -2045,7 +2109,7 @@ function createSvgObjectsFromSchDebugObject(debugObject, transform) {
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-trace.ts
-import { applyToPoint as applyToPoint24 } from "transformation-matrix";
+import { applyToPoint as applyToPoint25 } from "transformation-matrix";
 function createSchematicTrace(trace, transform) {
   const edges = trace.edges;
   if (edges.length === 0) return [];
@@ -2054,11 +2118,11 @@ function createSchematicTrace(trace, transform) {
   for (let edgeIndex = 0; edgeIndex < edges.length; edgeIndex++) {
     const edge = edges[edgeIndex];
     if (edge.is_crossing) continue;
-    const [screenFromX, screenFromY] = applyToPoint24(transform, [
+    const [screenFromX, screenFromY] = applyToPoint25(transform, [
       edge.from.x,
       edge.from.y
     ]);
-    const [screenToX, screenToY] = applyToPoint24(transform, [
+    const [screenToX, screenToY] = applyToPoint25(transform, [
       edge.to.x,
       edge.to.y
     ]);
@@ -2070,11 +2134,11 @@ function createSchematicTrace(trace, transform) {
   }
   for (const edge of edges) {
     if (!edge.is_crossing) continue;
-    const [screenFromX, screenFromY] = applyToPoint24(transform, [
+    const [screenFromX, screenFromY] = applyToPoint25(transform, [
       edge.from.x,
       edge.from.y
     ]);
-    const [screenToX, screenToY] = applyToPoint24(transform, [
+    const [screenToX, screenToY] = applyToPoint25(transform, [
       edge.to.x,
       edge.to.y
     ]);
@@ -2150,7 +2214,7 @@ function createSchematicTrace(trace, transform) {
   }
   if (trace.junctions) {
     for (const junction of trace.junctions) {
-      const [screenX, screenY] = applyToPoint24(transform, [
+      const [screenX, screenY] = applyToPoint25(transform, [
         junction.x,
         junction.y
       ]);
@@ -2183,7 +2247,7 @@ function createSchematicTrace(trace, transform) {
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-net-label.ts
 import {
-  applyToPoint as applyToPoint25,
+  applyToPoint as applyToPoint26,
   compose as compose6,
   rotate as rotate3,
   scale as scale3,
@@ -2979,14 +3043,14 @@ var createSvgObjectsForSchNetLabel = (schNetLabel, realToScreenTransform) => {
   const fontSizePx = getSchScreenFontSize(realToScreenTransform, "net_label");
   const fontSizeMm = getSchMmFontSize("net_label");
   const textWidthFSR = estimateTextWidth(schNetLabel.text || "");
-  const screenCenter = applyToPoint25(realToScreenTransform, schNetLabel.center);
+  const screenCenter = applyToPoint26(realToScreenTransform, schNetLabel.center);
   const realTextGrowthVec = getUnitVectorFromOutsideToEdge(
     schNetLabel.anchor_side
   );
   const screenTextGrowthVec = { ...realTextGrowthVec };
   screenTextGrowthVec.y *= -1;
   const fullWidthFsr = textWidthFSR + ARROW_POINT_WIDTH_FSR * 2 + END_PADDING_EXTRA_PER_CHARACTER_FSR * schNetLabel.text.length + END_PADDING_FSR;
-  const screenAnchorPosition = schNetLabel.anchor_position ? applyToPoint25(realToScreenTransform, schNetLabel.anchor_position) : {
+  const screenAnchorPosition = schNetLabel.anchor_position ? applyToPoint26(realToScreenTransform, schNetLabel.anchor_position) : {
     x: screenCenter.x - screenTextGrowthVec.x * fullWidthFsr * fontSizePx / 2,
     y: screenCenter.y - screenTextGrowthVec.y * fullWidthFsr * fontSizePx / 2
   };
@@ -3027,7 +3091,7 @@ var createSvgObjectsForSchNetLabel = (schNetLabel, realToScreenTransform) => {
       y: -0.6
     }
   ].map(
-    (fontRelativePoint) => applyToPoint25(
+    (fontRelativePoint) => applyToPoint26(
       compose6(
         realToScreenTransform,
         translate6(realAnchorPosition.x, realAnchorPosition.y),
@@ -3104,9 +3168,9 @@ var createSvgObjectsForSchNetLabel = (schNetLabel, realToScreenTransform) => {
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-text.ts
-import { applyToPoint as applyToPoint26 } from "transformation-matrix";
+import { applyToPoint as applyToPoint27 } from "transformation-matrix";
 var createSvgSchText = (elm, transform) => {
-  const center = applyToPoint26(transform, elm.position);
+  const center = applyToPoint27(transform, elm.position);
   const textAnchorMap = {
     center: "middle",
     left: "start",
@@ -3147,6 +3211,265 @@ var createSvgSchText = (elm, transform) => {
   };
 };
 
+// lib/sch/svg-object-fns/create-svg-objects-for-sch-net-symbol.ts
+import {
+  applyToPoint as applyToPoint28,
+  compose as compose7,
+  rotate as rotate4,
+  scale as scale4,
+  translate as translate7
+} from "transformation-matrix";
+import { symbols as symbols3 } from "schematic-symbols";
+var ninePointAnchorToTextAnchor2 = {
+  top_left: "start",
+  top_right: "end",
+  middle_left: "start",
+  middle_right: "end",
+  bottom_left: "start",
+  bottom_right: "end",
+  center: "middle",
+  middle_top: "middle",
+  middle_bottom: "middle"
+};
+var ninePointAnchorToDominantBaseline2 = {
+  top_left: "auto",
+  top_right: "auto",
+  bottom_left: "hanging",
+  bottom_right: "hanging",
+  center: "auto",
+  middle_left: "middle",
+  middle_right: "middle",
+  middle_top: "auto",
+  middle_bottom: "hanging"
+};
+var ARROW_POINT_WIDTH_FSR2 = 0.3;
+var END_PADDING_FSR2 = 0.3;
+var END_PADDING_EXTRA_PER_CHARACTER_FSR2 = 0.06;
+var createSvgObjectsForSchNetSymbol = (schNetLabel, realToScreenTransform) => {
+  if (!schNetLabel.text) return [];
+  const svgObjects = [];
+  const symbol = symbols3["ground_horz"];
+  if (!symbol) {
+    svgObjects.push(
+      createSvgSchErrorText({
+        text: `Symbol not found: ${schNetLabel.symbol_name}`,
+        realCenter: schNetLabel.center,
+        realToScreenTransform
+      })
+    );
+    return svgObjects;
+  }
+  const symbolPaths = symbol.primitives.filter((p) => p.type === "path");
+  const symbolTexts = symbol.primitives.filter((p) => p.type === "text");
+  const symbolCircles = symbol.primitives.filter((p) => p.type === "circle");
+  const symbolBoxes = symbol.primitives.filter((p) => p.type === "box");
+  const bounds = {
+    minX: Math.min(...symbolPaths.flatMap((p) => p.points.map((pt) => pt.x))),
+    maxX: Math.max(...symbolPaths.flatMap((p) => p.points.map((pt) => pt.x))),
+    minY: Math.min(...symbolPaths.flatMap((p) => p.points.map((pt) => pt.y))),
+    maxY: Math.max(...symbolPaths.flatMap((p) => p.points.map((pt) => pt.y)))
+  };
+  const fontSizeMm = getSchMmFontSize("net_label");
+  const textWidthFSR = estimateTextWidth(schNetLabel.text || "");
+  const fullWidthFsr = textWidthFSR + ARROW_POINT_WIDTH_FSR2 * 2 + END_PADDING_EXTRA_PER_CHARACTER_FSR2 * schNetLabel.text.length + END_PADDING_FSR2;
+  const realTextGrowthVec = getUnitVectorFromOutsideToEdge(
+    schNetLabel.anchor_side
+  );
+  const realAnchorPosition = schNetLabel.anchor_position ?? {
+    x: schNetLabel.center.x - realTextGrowthVec.x * fullWidthFsr * fontSizeMm / 2,
+    y: schNetLabel.center.y - realTextGrowthVec.y * fullWidthFsr * fontSizeMm / 2
+  };
+  const pathRotation = {
+    left: 0,
+    top: -90,
+    bottom: 90,
+    right: 180
+  }[schNetLabel.anchor_side];
+  const rotationMatrix = rotate4(pathRotation / 180 * Math.PI);
+  const symbolBounds = {
+    minX: Math.min(
+      ...symbol.primitives.flatMap(
+        (p) => p.type === "path" ? p.points.map((pt) => pt.x) : []
+      )
+    ),
+    maxX: Math.max(
+      ...symbol.primitives.flatMap(
+        (p) => p.type === "path" ? p.points.map((pt) => pt.x) : []
+      )
+    ),
+    minY: Math.min(
+      ...symbol.primitives.flatMap(
+        (p) => p.type === "path" ? p.points.map((pt) => pt.y) : []
+      )
+    ),
+    maxY: Math.max(
+      ...symbol.primitives.flatMap(
+        (p) => p.type === "path" ? p.points.map((pt) => pt.y) : []
+      )
+    )
+  };
+  const symbolEndPoint = {
+    x: symbolBounds.minX,
+    y: (symbolBounds.minY + symbolBounds.maxY) / 2
+  };
+  const rotatedSymbolEnd = applyToPoint28(rotationMatrix, symbolEndPoint);
+  const symbolToRealTransform = compose7(
+    translate7(
+      realAnchorPosition.x - rotatedSymbolEnd.x,
+      realAnchorPosition.y - rotatedSymbolEnd.y
+    ),
+    rotationMatrix,
+    scale4(1)
+    // Use full symbol size
+  );
+  const [screenMinX, screenMinY] = applyToPoint28(
+    compose7(realToScreenTransform, symbolToRealTransform),
+    [bounds.minX, bounds.minY]
+  );
+  const [screenMaxX, screenMaxY] = applyToPoint28(
+    compose7(realToScreenTransform, symbolToRealTransform),
+    [bounds.maxX, bounds.maxY]
+  );
+  const rectHeight = Math.abs(screenMaxY - screenMinY);
+  const rectY = Math.min(screenMinY, screenMaxY);
+  const rectWidth = Math.abs(screenMaxX - screenMinX);
+  const rectX = Math.min(screenMinX, screenMaxX);
+  svgObjects.push({
+    name: "rect",
+    type: "element",
+    value: "",
+    attributes: {
+      class: "component-overlay",
+      x: rectX.toString(),
+      y: rectY.toString(),
+      width: rectWidth.toString(),
+      height: rectHeight.toString(),
+      fill: "transparent"
+    },
+    children: []
+  });
+  for (const path of symbolPaths) {
+    const symbolPath = path.points.map((p, i) => {
+      const [x, y] = applyToPoint28(
+        compose7(realToScreenTransform, symbolToRealTransform),
+        [p.x, p.y]
+      );
+      return `${i === 0 ? "M" : "L"} ${x} ${y}`;
+    }).join(" ");
+    svgObjects.push({
+      name: "path",
+      type: "element",
+      attributes: {
+        d: symbolPath + (path.closed ? " Z" : ""),
+        stroke: colorMap.schematic.component_outline,
+        fill: "none",
+        "stroke-width": `${getSchStrokeSize(realToScreenTransform)}px`
+      },
+      value: "",
+      children: []
+    });
+  }
+  for (const text of symbolTexts) {
+    const screenTextPos = applyToPoint28(
+      compose7(realToScreenTransform, symbolToRealTransform),
+      text
+    );
+    let textValue = text.text;
+    if (textValue === "{REF}") {
+      textValue = schNetLabel.text || "";
+    } else if (textValue === "{VAL}") {
+      textValue = "";
+    }
+    const rotationOffsetMap = {
+      "0": { x: 8, y: -10 },
+      // Left
+      "-90": { x: 33, y: 28 },
+      // Top
+      "90": { x: -32.5, y: -38 },
+      // Bottom
+      "180": { x: -8.5, y: -2 }
+      // Right
+    };
+    const currentRotation = pathRotation.toString();
+    const rotationOffset = rotationOffsetMap[currentRotation] || { x: 0, y: 0 };
+    const offsetScreenPos = {
+      x: screenTextPos.x + rotationOffset.x,
+      y: screenTextPos.y + rotationOffset.y
+    };
+    svgObjects.push({
+      name: "text",
+      type: "element",
+      attributes: {
+        x: offsetScreenPos.x.toString(),
+        y: offsetScreenPos.y.toString(),
+        fill: colorMap.schematic.label_global,
+        "font-family": "sans-serif",
+        "text-anchor": ninePointAnchorToTextAnchor2[text.anchor],
+        "dominant-baseline": ninePointAnchorToDominantBaseline2[text.anchor],
+        "font-size": `${getSchScreenFontSize(realToScreenTransform, "reference_designator")}px`
+      },
+      children: [
+        {
+          type: "text",
+          value: textValue,
+          name: "",
+          attributes: {},
+          children: []
+        }
+      ],
+      value: ""
+    });
+  }
+  for (const box of symbolBoxes) {
+    const screenBoxPos = applyToPoint28(
+      compose7(realToScreenTransform, symbolToRealTransform),
+      box
+    );
+    const symbolToScreenScale = compose7(
+      realToScreenTransform,
+      symbolToRealTransform
+    ).a;
+    svgObjects.push({
+      name: "rect",
+      type: "element",
+      attributes: {
+        x: screenBoxPos.x.toString(),
+        y: screenBoxPos.y.toString(),
+        width: (box.width * symbolToScreenScale).toString(),
+        height: (box.height * symbolToScreenScale).toString(),
+        fill: "red"
+      },
+      value: "",
+      children: []
+    });
+  }
+  for (const circle of symbolCircles) {
+    const screenCirclePos = applyToPoint28(
+      compose7(realToScreenTransform, symbolToRealTransform),
+      circle
+    );
+    const symbolToScreenScale = compose7(
+      realToScreenTransform,
+      symbolToRealTransform
+    ).a;
+    svgObjects.push({
+      name: "circle",
+      type: "element",
+      attributes: {
+        cx: screenCirclePos.x.toString(),
+        cy: screenCirclePos.y.toString(),
+        r: (circle.radius * symbolToScreenScale).toString(),
+        fill: "none",
+        stroke: colorMap.schematic.component_outline,
+        "stroke-width": `${getSchStrokeSize(realToScreenTransform)}px`
+      },
+      value: "",
+      children: []
+    });
+  }
+  return svgObjects;
+};
+
 // lib/sch/convert-circuit-json-to-schematic-svg.ts
 function convertCircuitJsonToSchematicSvg(circuitJson, options) {
   const realBounds = getSchematicBoundsFromCircuitJson(circuitJson);
@@ -3207,6 +3530,7 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
   const schTraceSvgs = [];
   const schNetLabel = [];
   const schText = [];
+  const voltageProbeSvgs = [];
   for (const elm of circuitJson) {
     if (elm.type === "schematic_debug_object") {
       schDebugObjectSvgs.push(
@@ -3223,9 +3547,13 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
     } else if (elm.type === "schematic_trace") {
       schTraceSvgs.push(...createSchematicTrace(elm, transform));
     } else if (elm.type === "schematic_net_label") {
-      schNetLabel.push(...createSvgObjectsForSchNetLabel(elm, transform));
+      elm.symbol_name ? schNetLabel.push(...createSvgObjectsForSchNetSymbol(elm, transform)) : schNetLabel.push(...createSvgObjectsForSchNetLabel(elm, transform));
     } else if (elm.type === "schematic_text") {
       schText.push(createSvgSchText(elm, transform));
+    } else if (elm.type === "schematic_voltage_probe") {
+      voltageProbeSvgs.push(
+        ...createSvgObjectsFromSchVoltageProbe(elm, transform)
+      );
     }
   }
   svgChildren.push(
@@ -3233,7 +3561,8 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
     ...schComponentSvgs,
     ...schTraceSvgs,
     ...schNetLabel,
-    ...schText
+    ...schText,
+    ...voltageProbeSvgs
   );
   if (options?.labeledPoints) {
     svgChildren.push(