circuit-to-svg 0.0.194 → 0.0.196

package/dist/index.js

@@ -1031,110 +1031,187 @@ import { applyToPoint as applyToPoint11 } from "transformation-matrix";
 function createSvgObjectsFromSmtPad(pad, ctx) {
   const { transform, layer: layerFilter, colorMap: colorMap2 } = ctx;
   if (layerFilter && pad.layer !== layerFilter) return [];
+  const isCoveredWithSolderMask = Boolean(pad?.is_covered_with_solder_mask);
+  const solderMaskColor = colorMap2.soldermask[pad.layer] ?? colorMap2.soldermask.top;
   if (pad.shape === "rect" || pad.shape === "rotated_rect") {
     const width = pad.width * Math.abs(transform.a);
     const height = pad.height * Math.abs(transform.d);
     const [x, y] = applyToPoint11(transform, [pad.x, pad.y]);
     const scaledBorderRadius = (pad.rect_border_radius ?? 0) * Math.abs(transform.a);
     if (pad.shape === "rotated_rect" && pad.ccw_rotation) {
-      return [
-        {
-          name: "rect",
-          type: "element",
-          attributes: {
-            class: "pcb-pad",
-            fill: layerNameToColor(pad.layer, colorMap2),
-            x: (-width / 2).toString(),
-            y: (-height / 2).toString(),
-            width: width.toString(),
-            height: height.toString(),
-            transform: `translate(${x} ${y}) rotate(${-pad.ccw_rotation})`,
-            "data-layer": pad.layer,
-            ...scaledBorderRadius ? {
-              rx: scaledBorderRadius.toString(),
-              ry: scaledBorderRadius.toString()
-            } : {}
-          }
-        }
-      ];
-    }
-    return [
-      {
+      const padElement2 = {
         name: "rect",
         type: "element",
+        value: "",
+        children: [],
         attributes: {
           class: "pcb-pad",
           fill: layerNameToColor(pad.layer, colorMap2),
-          x: (x - width / 2).toString(),
-          y: (y - height / 2).toString(),
+          x: (-width / 2).toString(),
+          y: (-height / 2).toString(),
           width: width.toString(),
           height: height.toString(),
+          transform: `translate(${x} ${y}) rotate(${-pad.ccw_rotation})`,
           "data-layer": pad.layer,
           ...scaledBorderRadius ? {
             rx: scaledBorderRadius.toString(),
             ry: scaledBorderRadius.toString()
           } : {}
         }
+      };
+      if (!isCoveredWithSolderMask) {
+        return [padElement2];
       }
-    ];
+      const maskElement2 = {
+        name: padElement2.name,
+        type: padElement2.type,
+        value: "",
+        children: [],
+        attributes: {
+          ...padElement2.attributes,
+          class: "pcb-solder-mask",
+          fill: solderMaskColor
+        }
+      };
+      return [padElement2, maskElement2];
+    }
+    const padElement = {
+      name: "rect",
+      type: "element",
+      value: "",
+      children: [],
+      attributes: {
+        class: "pcb-pad",
+        fill: layerNameToColor(pad.layer, colorMap2),
+        x: (x - width / 2).toString(),
+        y: (y - height / 2).toString(),
+        width: width.toString(),
+        height: height.toString(),
+        "data-layer": pad.layer,
+        ...scaledBorderRadius ? {
+          rx: scaledBorderRadius.toString(),
+          ry: scaledBorderRadius.toString()
+        } : {}
+      }
+    };
+    if (!isCoveredWithSolderMask) {
+      return [padElement];
+    }
+    const maskElement = {
+      name: padElement.name,
+      type: padElement.type,
+      value: "",
+      children: [],
+      attributes: {
+        ...padElement.attributes,
+        class: "pcb-solder-mask",
+        fill: solderMaskColor
+      }
+    };
+    return [padElement, maskElement];
   }
   if (pad.shape === "pill") {
     const width = pad.width * Math.abs(transform.a);
     const height = pad.height * Math.abs(transform.d);
     const radius = pad.radius * Math.abs(transform.a);
     const [x, y] = applyToPoint11(transform, [pad.x, pad.y]);
-    return [
-      {
-        name: "rect",
-        type: "element",
-        attributes: {
-          class: "pcb-pad",
-          fill: layerNameToColor(pad.layer, colorMap2),
-          x: (x - width / 2).toString(),
-          y: (y - height / 2).toString(),
-          width: width.toString(),
-          height: height.toString(),
-          rx: radius.toString(),
-          ry: radius.toString(),
-          "data-layer": pad.layer
-        }
+    const padElement = {
+      name: "rect",
+      type: "element",
+      value: "",
+      children: [],
+      attributes: {
+        class: "pcb-pad",
+        fill: layerNameToColor(pad.layer, colorMap2),
+        x: (x - width / 2).toString(),
+        y: (y - height / 2).toString(),
+        width: width.toString(),
+        height: height.toString(),
+        rx: radius.toString(),
+        ry: radius.toString(),
+        "data-layer": pad.layer
       }
-    ];
+    };
+    if (!isCoveredWithSolderMask) {
+      return [padElement];
+    }
+    const maskElement = {
+      name: padElement.name,
+      type: padElement.type,
+      value: "",
+      children: [],
+      attributes: {
+        ...padElement.attributes,
+        class: "pcb-solder-mask",
+        fill: solderMaskColor
+      }
+    };
+    return [padElement, maskElement];
   }
   if (pad.shape === "circle") {
     const radius = pad.radius * Math.abs(transform.a);
     const [x, y] = applyToPoint11(transform, [pad.x, pad.y]);
-    return [
-      {
-        name: "circle",
-        type: "element",
-        attributes: {
-          class: "pcb-pad",
-          fill: layerNameToColor(pad.layer, colorMap2),
-          cx: x.toString(),
-          cy: y.toString(),
-          r: radius.toString(),
-          "data-layer": pad.layer
-        }
+    const padElement = {
+      name: "circle",
+      type: "element",
+      value: "",
+      children: [],
+      attributes: {
+        class: "pcb-pad",
+        fill: layerNameToColor(pad.layer, colorMap2),
+        cx: x.toString(),
+        cy: y.toString(),
+        r: radius.toString(),
+        "data-layer": pad.layer
       }
-    ];
+    };
+    if (!isCoveredWithSolderMask) {
+      return [padElement];
+    }
+    const maskElement = {
+      name: padElement.name,
+      type: padElement.type,
+      value: "",
+      children: [],
+      attributes: {
+        ...padElement.attributes,
+        class: "pcb-solder-mask",
+        fill: solderMaskColor
+      }
+    };
+    return [padElement, maskElement];
   }
   if (pad.shape === "polygon") {
     const points = (pad.points ?? []).map(
       (point) => applyToPoint11(transform, [point.x, point.y])
     );
-    return [
-      {
-        name: "polygon",
-        type: "element",
-        attributes: {
-          class: "pcb-pad",
-          fill: layerNameToColor(pad.layer),
-          points: points.map((p) => p.join(",")).join(" "),
-          "data-layer": pad.layer
-        }
+    const padElement = {
+      name: "polygon",
+      type: "element",
+      value: "",
+      children: [],
+      attributes: {
+        class: "pcb-pad",
+        fill: layerNameToColor(pad.layer, colorMap2),
+        points: points.map((p) => p.join(",")).join(" "),
+        "data-layer": pad.layer
       }
-    ];
+    };
+    if (!isCoveredWithSolderMask) {
+      return [padElement];
+    }
+    const maskElement = {
+      name: padElement.name,
+      type: padElement.type,
+      value: "",
+      children: [],
+      attributes: {
+        ...padElement.attributes,
+        class: "pcb-solder-mask",
+        fill: solderMaskColor
+      }
+    };
+    return [padElement, maskElement];
   }
   return [];
 }
@@ -1666,7 +1743,7 @@ function getSoftwareUsedString(circuitJson) {
 var package_default = {
   name: "circuit-to-svg",
   type: "module",
-  version: "0.0.193",
+  version: "0.0.195",
   description: "Convert Circuit JSON to SVG",
   main: "dist/index.js",
   files: [
@@ -1690,12 +1767,12 @@ var package_default = {
     "bun-match-svg": "^0.0.12",
     esbuild: "^0.20.2",
     "performance-now": "^2.1.0",
-    "circuit-json": "^0.0.257",
+    "circuit-json": "^0.0.260",
     react: "19.1.0",
     "react-cosmos": "7.0.0",
     "react-cosmos-plugin-vite": "7.0.0",
     "react-dom": "19.1.0",
-    tscircuit: "^0.0.648",
+    tscircuit: "^0.0.654",
     tsup: "^8.0.2",
     typescript: "^5.4.5",
     "vite-tsconfig-paths": "^5.0.1"
@@ -1808,10 +1885,10 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
     }
   }
   const padding = drawPaddingOutsideBoard ? 1 : 0;
-  const boundsMinX = drawPaddingOutsideBoard || !isFinite(boardMinX) ? minX : boardMinX;
-  const boundsMinY = drawPaddingOutsideBoard || !isFinite(boardMinY) ? minY : boardMinY;
-  const boundsMaxX = drawPaddingOutsideBoard || !isFinite(boardMaxX) ? maxX : boardMaxX;
-  const boundsMaxY = drawPaddingOutsideBoard || !isFinite(boardMaxY) ? maxY : boardMaxY;
+  const boundsMinX = drawPaddingOutsideBoard || !Number.isFinite(boardMinX) ? minX : boardMinX;
+  const boundsMinY = drawPaddingOutsideBoard || !Number.isFinite(boardMinY) ? minY : boardMinY;
+  const boundsMaxX = drawPaddingOutsideBoard || !Number.isFinite(boardMaxX) ? maxX : boardMaxX;
+  const boundsMaxY = drawPaddingOutsideBoard || !Number.isFinite(boardMaxY) ? maxY : boardMaxY;
   const circuitWidth = boundsMaxX - boundsMinX + 2 * padding;
   const circuitHeight = boundsMaxY - boundsMinY + 2 * padding;
   let svgWidth = options?.width ?? 800;
@@ -4390,6 +4467,27 @@ function getSchematicBoundsFromCircuitJson(soup, padding = 0.5) {
         { width: totalWidth, height: totalHeight },
         0
       );
+    } else if (item.type === "schematic_line") {
+      updateBounds({ x: item.x1, y: item.y1 }, { width: 0.02, height: 0.02 }, 0);
+      updateBounds({ x: item.x2, y: item.y2 }, { width: 0.02, height: 0.02 }, 0);
+    } else if (item.type === "schematic_circle") {
+      updateBounds(
+        item.center,
+        { width: item.radius * 2, height: item.radius * 2 },
+        0
+      );
+    } else if (item.type === "schematic_rect") {
+      updateBounds(
+        item.center,
+        { width: item.width, height: item.height },
+        item.rotation
+      );
+    } else if (item.type === "schematic_arc") {
+      updateBounds(
+        item.center,
+        { width: item.radius * 2, height: item.radius * 2 },
+        0
+      );
     }
   }
   minX -= padding;
@@ -6303,6 +6401,170 @@ var createSvgObjectsForSchComponentPortHovers = ({
   return svgs;
 };
 
+// lib/sch/svg-object-fns/create-svg-objects-from-sch-line.ts
+import { applyToPoint as applyToPoint46 } from "transformation-matrix";
+function createSvgObjectsFromSchematicLine({
+  schLine,
+  transform,
+  colorMap: colorMap2
+}) {
+  const p1 = applyToPoint46(transform, { x: schLine.x1, y: schLine.y1 });
+  const p2 = applyToPoint46(transform, { x: schLine.x2, y: schLine.y2 });
+  const strokeWidth = schLine.stroke_width ?? 0.02;
+  const transformedStrokeWidth = Math.abs(transform.a) * strokeWidth;
+  return [
+    {
+      name: "line",
+      type: "element",
+      attributes: {
+        x1: p1.x.toString(),
+        y1: p1.y.toString(),
+        x2: p2.x.toString(),
+        y2: p2.y.toString(),
+        stroke: schLine.color,
+        "stroke-width": transformedStrokeWidth.toString(),
+        ...schLine.is_dashed && {
+          "stroke-dasharray": (transformedStrokeWidth * 3).toString()
+        },
+        "data-schematic-line-id": schLine.schematic_line_id,
+        ...schLine.schematic_component_id && {
+          "data-schematic-component-id": schLine.schematic_component_id
+        }
+      },
+      children: [],
+      value: ""
+    }
+  ];
+}
+
+// lib/sch/svg-object-fns/create-svg-objects-from-sch-circle.ts
+import { applyToPoint as applyToPoint47 } from "transformation-matrix";
+function createSvgObjectsFromSchematicCircle({
+  schCircle,
+  transform,
+  colorMap: colorMap2
+}) {
+  const center = applyToPoint47(transform, schCircle.center);
+  const transformedRadius = Math.abs(transform.a) * schCircle.radius;
+  const strokeWidth = schCircle.stroke_width ?? 0.02;
+  const transformedStrokeWidth = Math.abs(transform.a) * strokeWidth;
+  return [
+    {
+      name: "circle",
+      type: "element",
+      attributes: {
+        cx: center.x.toString(),
+        cy: center.y.toString(),
+        r: transformedRadius.toString(),
+        fill: schCircle.is_filled ? schCircle.fill_color ?? schCircle.color : "none",
+        stroke: schCircle.color,
+        "stroke-width": transformedStrokeWidth.toString(),
+        ...schCircle.is_dashed && {
+          "stroke-dasharray": (transformedStrokeWidth * 3).toString()
+        },
+        "data-schematic-circle-id": schCircle.schematic_circle_id,
+        ...schCircle.schematic_component_id && {
+          "data-schematic-component-id": schCircle.schematic_component_id
+        }
+      },
+      children: [],
+      value: ""
+    }
+  ];
+}
+
+// lib/sch/svg-object-fns/create-svg-objects-from-sch-rect.ts
+import { applyToPoint as applyToPoint48 } from "transformation-matrix";
+function createSvgObjectsFromSchematicRect({
+  schRect,
+  transform,
+  colorMap: colorMap2
+}) {
+  const center = applyToPoint48(transform, schRect.center);
+  const transformedWidth = Math.abs(transform.a) * schRect.width;
+  const transformedHeight = Math.abs(transform.d) * schRect.height;
+  const strokeWidth = schRect.stroke_width ?? 0.02;
+  const transformedStrokeWidth = Math.abs(transform.a) * strokeWidth;
+  const x = center.x - transformedWidth / 2;
+  const y = center.y - transformedHeight / 2;
+  const svgRect = {
+    name: "rect",
+    type: "element",
+    attributes: {
+      x: x.toString(),
+      y: y.toString(),
+      width: transformedWidth.toString(),
+      height: transformedHeight.toString(),
+      fill: schRect.is_filled ? schRect.fill_color ?? schRect.color : "none",
+      stroke: schRect.color,
+      "stroke-width": transformedStrokeWidth.toString(),
+      ...schRect.is_dashed && {
+        "stroke-dasharray": (transformedStrokeWidth * 3).toString()
+      },
+      ...schRect.rotation !== 0 && {
+        transform: `rotate(${schRect.rotation} ${center.x} ${center.y})`
+      },
+      "data-schematic-rect-id": schRect.schematic_rect_id,
+      ...schRect.schematic_component_id && {
+        "data-schematic-component-id": schRect.schematic_component_id
+      }
+    },
+    children: [],
+    value: ""
+  };
+  return [svgRect];
+}
+
+// lib/sch/svg-object-fns/create-svg-objects-from-sch-arc.ts
+import { applyToPoint as applyToPoint49 } from "transformation-matrix";
+function createSvgObjectsFromSchematicArc({
+  schArc,
+  transform,
+  colorMap: colorMap2
+}) {
+  const center = applyToPoint49(transform, schArc.center);
+  const transformedRadius = Math.abs(transform.a) * schArc.radius;
+  const strokeWidth = schArc.stroke_width ?? 0.02;
+  const transformedStrokeWidth = Math.abs(transform.a) * strokeWidth;
+  const startAngleRad = schArc.start_angle_degrees * Math.PI / 180;
+  const endAngleRad = schArc.end_angle_degrees * Math.PI / 180;
+  const startX = center.x + transformedRadius * Math.cos(startAngleRad);
+  const startY = center.y + transformedRadius * Math.sin(startAngleRad);
+  const endX = center.x + transformedRadius * Math.cos(endAngleRad);
+  const endY = center.y + transformedRadius * Math.sin(endAngleRad);
+  let angleDiff = schArc.end_angle_degrees - schArc.start_angle_degrees;
+  if (schArc.direction === "clockwise") {
+    angleDiff = -angleDiff;
+  }
+  if (angleDiff < 0) {
+    angleDiff += 360;
+  }
+  const largeArcFlag = angleDiff > 180 ? 1 : 0;
+  const sweepFlag = schArc.direction === "clockwise" ? 1 : 0;
+  const pathData = `M ${startX} ${startY} A ${transformedRadius} ${transformedRadius} 0 ${largeArcFlag} ${sweepFlag} ${endX} ${endY}`;
+  return [
+    {
+      name: "path",
+      type: "element",
+      attributes: {
+        d: pathData,
+        fill: "none",
+        stroke: schArc.color,
+        "stroke-width": transformedStrokeWidth.toString(),
+        ...schArc.is_dashed && {
+          "stroke-dasharray": (transformedStrokeWidth * 3).toString()
+        },
+        "data-schematic-arc-id": schArc.schematic_arc_id,
+        ...schArc.schematic_component_id && {
+          "data-schematic-component-id": schArc.schematic_component_id
+        }
+      },
+      children: [],
+      value: ""
+    }
+  ];
+}
+
 // lib/sch/convert-circuit-json-to-schematic-svg.ts
 function buildNetHoverStyles(connectivityKeys) {
   const rules = [];
@@ -6393,6 +6655,10 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
   const schBoxSvgs = [];
   const schTableSvgs = [];
   const schPortHoverSvgs = [];
+  const schLineSvgs = [];
+  const schCircleSvgs = [];
+  const schRectSvgs = [];
+  const schArcSvgs = [];
   for (const elm of circuitJson) {
     if (elm.type === "schematic_debug_object") {
       schDebugObjectSvgs.push(
@@ -6467,6 +6733,38 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
           circuitJson
         })
       );
+    } else if (elm.type === "schematic_line") {
+      schLineSvgs.push(
+        ...createSvgObjectsFromSchematicLine({
+          schLine: elm,
+          transform,
+          colorMap: colorMap2
+        })
+      );
+    } else if (elm.type === "schematic_circle") {
+      schCircleSvgs.push(
+        ...createSvgObjectsFromSchematicCircle({
+          schCircle: elm,
+          transform,
+          colorMap: colorMap2
+        })
+      );
+    } else if (elm.type === "schematic_rect") {
+      schRectSvgs.push(
+        ...createSvgObjectsFromSchematicRect({
+          schRect: elm,
+          transform,
+          colorMap: colorMap2
+        })
+      );
+    } else if (elm.type === "schematic_arc") {
+      schArcSvgs.push(
+        ...createSvgObjectsFromSchematicArc({
+          schArc: elm,
+          transform,
+          colorMap: colorMap2
+        })
+      );
     }
   }
   const schTraceBaseSvgs = schTraceSvgs.filter(
@@ -6479,6 +6777,10 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
     ...schDebugObjectSvgs,
     ...schTraceBaseSvgs,
     ...schTraceOverlaySvgs,
+    ...schLineSvgs,
+    ...schCircleSvgs,
+    ...schRectSvgs,
+    ...schArcSvgs,
     ...schComponentSvgs,
     ...schPortHoverSvgs,
     ...schNetLabel,
@@ -6567,18 +6869,18 @@ var circuitJsonToSchematicSvg = convertCircuitJsonToSchematicSvg;
 // lib/pcb/convert-circuit-json-to-solder-paste-mask.ts
 import { stringify as stringify4 } from "svgson";
 import {
-  applyToPoint as applyToPoint48,
-  compose as compose12,
+  applyToPoint as applyToPoint52,
+  compose as compose13,
   scale as scale8,
-  translate as translate12
+  translate as translate13
 } from "transformation-matrix";
 
 // lib/pcb/svg-object-fns/convert-circuit-json-to-solder-paste-mask.ts
-import { applyToPoint as applyToPoint47 } from "transformation-matrix";
+import { applyToPoint as applyToPoint51 } from "transformation-matrix";
 function createSvgObjectsFromSolderPaste(solderPaste, ctx) {
   const { transform, layer: layerFilter } = ctx;
   if (layerFilter && solderPaste.layer !== layerFilter) return [];
-  const [x, y] = applyToPoint47(transform, [solderPaste.x, solderPaste.y]);
+  const [x, y] = applyToPoint51(transform, [solderPaste.x, solderPaste.y]);
   if (solderPaste.shape === "rect" || solderPaste.shape === "rotated_rect") {
     const width = solderPaste.width * Math.abs(transform.a);
     const height = solderPaste.height * Math.abs(transform.d);
@@ -6686,8 +6988,8 @@ function convertCircuitJsonToSolderPasteMask(circuitJson, options) {
   const scaleFactor = Math.min(scaleX, scaleY);
   const offsetX = (svgWidth - circuitWidth * scaleFactor) / 2;
   const offsetY = (svgHeight - circuitHeight * scaleFactor) / 2;
-  const transform = compose12(
-    translate12(
+  const transform = compose13(
+    translate13(
       offsetX - minX * scaleFactor + padding * scaleFactor,
       svgHeight - offsetY + minY * scaleFactor - padding * scaleFactor
     ),
@@ -6781,8 +7083,8 @@ function createSvgObjects3({ elm, ctx }) {
   }
 }
 function createSvgObjectFromPcbBoundary2(transform, minX, minY, maxX, maxY) {
-  const [x1, y1] = applyToPoint48(transform, [minX, minY]);
-  const [x2, y2] = applyToPoint48(transform, [maxX, maxY]);
+  const [x1, y1] = applyToPoint52(transform, [minX, minY]);
+  const [x2, y2] = applyToPoint52(transform, [maxX, maxY]);
   const width = Math.abs(x2 - x1);
   const height = Math.abs(y2 - y1);
   const x = Math.min(x1, x2);