circuit-to-svg 0.0.252 → 0.0.253

package/dist/index.js

@@ -3339,7 +3339,7 @@ function getSoftwareUsedString(circuitJson) {
 var package_default = {
   name: "circuit-to-svg",
   type: "module",
-  version: "0.0.251",
+  version: "0.0.252",
   description: "Convert Circuit JSON to SVG",
   main: "dist/index.js",
   files: [
@@ -3499,15 +3499,20 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
   let minY = Number.POSITIVE_INFINITY;
   let maxX = Number.NEGATIVE_INFINITY;
   let maxY = Number.NEGATIVE_INFINITY;
+  let hasBounds = false;
   let boardMinX = Number.POSITIVE_INFINITY;
   let boardMinY = Number.POSITIVE_INFINITY;
   let boardMaxX = Number.NEGATIVE_INFINITY;
   let boardMaxY = Number.NEGATIVE_INFINITY;
+  let hasBoardBounds = false;
   for (const circuitJsonElm of circuitJson) {
     if (circuitJsonElm.type === "pcb_panel") {
       const panel = circuitJsonElm;
-      const width = Number(panel.width);
-      const height = Number(panel.height);
+      const width = toNumeric(panel.width);
+      const height = toNumeric(panel.height);
+      if (width === void 0 || height === void 0) {
+        continue;
+      }
       const center = { x: width / 2, y: height / 2 };
       updateBounds(center, width, height);
       updateBoardBounds(center, width, height);
@@ -3534,7 +3539,10 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
       if (pad.shape === "rect" || pad.shape === "rotated_rect" || pad.shape === "pill") {
         updateBounds({ x: pad.x, y: pad.y }, pad.width, pad.height);
       } else if (pad.shape === "circle") {
-        updateBounds({ x: pad.x, y: pad.y }, pad.radius * 2, pad.radius * 2);
+        const radius = toNumeric(pad.radius);
+        if (radius !== void 0) {
+          updateBounds({ x: pad.x, y: pad.y }, radius * 2, radius * 2);
+        }
       } else if (pad.shape === "polygon") {
         updateTraceBounds(pad.points);
       }
@@ -3551,7 +3559,10 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
       if (cutout.shape === "rect") {
         updateBounds(cutout.center, cutout.width, cutout.height);
       } else if (cutout.shape === "circle") {
-        updateBounds(cutout.center, cutout.radius * 2, cutout.radius * 2);
+        const radius = toNumeric(cutout.radius);
+        if (radius !== void 0) {
+          updateBounds(cutout.center, radius * 2, radius * 2);
+        }
       } else if (cutout.shape === "polygon") {
         updateTraceBounds(cutout.points);
       }
@@ -3711,44 +3722,94 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
     console.error("Error stringifying SVG object:", error);
     throw error;
   }
+  function toNumeric(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : void 0;
+    }
+    if (typeof value === "string") {
+      const parsed = Number.parseFloat(value);
+      return Number.isFinite(parsed) ? parsed : void 0;
+    }
+    return void 0;
+  }
   function updateBounds(center, width, height) {
-    const halfWidth = width / 2;
-    const halfHeight = height / 2;
-    minX = Math.min(minX, center.x - halfWidth);
-    minY = Math.min(minY, center.y - halfHeight);
-    maxX = Math.max(maxX, center.x + halfWidth);
-    maxY = Math.max(maxY, center.y + halfHeight);
+    if (!center) return;
+    const centerX = toNumeric(center.x);
+    const centerY = toNumeric(center.y);
+    if (centerX === void 0 || centerY === void 0) return;
+    const numericWidth = toNumeric(width) ?? 0;
+    const numericHeight = toNumeric(height) ?? 0;
+    const halfWidth = numericWidth / 2;
+    const halfHeight = numericHeight / 2;
+    minX = Math.min(minX, centerX - halfWidth);
+    minY = Math.min(minY, centerY - halfHeight);
+    maxX = Math.max(maxX, centerX + halfWidth);
+    maxY = Math.max(maxY, centerY + halfHeight);
+    hasBounds = true;
   }
   function updateBoardBounds(center, width, height) {
-    const halfWidth = width / 2;
-    const halfHeight = height / 2;
-    boardMinX = Math.min(boardMinX, center.x - halfWidth);
-    boardMinY = Math.min(boardMinY, center.y - halfHeight);
-    boardMaxX = Math.max(boardMaxX, center.x + halfWidth);
-    boardMaxY = Math.max(boardMaxY, center.y + halfHeight);
+    if (!center) return;
+    const centerX = toNumeric(center.x);
+    const centerY = toNumeric(center.y);
+    if (centerX === void 0 || centerY === void 0) return;
+    const numericWidth = toNumeric(width) ?? 0;
+    const numericHeight = toNumeric(height) ?? 0;
+    const halfWidth = numericWidth / 2;
+    const halfHeight = numericHeight / 2;
+    boardMinX = Math.min(boardMinX, centerX - halfWidth);
+    boardMinY = Math.min(boardMinY, centerY - halfHeight);
+    boardMaxX = Math.max(boardMaxX, centerX + halfWidth);
+    boardMaxY = Math.max(boardMaxY, centerY + halfHeight);
+    hasBounds = true;
+    hasBoardBounds = true;
   }
   function updateBoundsToIncludeOutline(outline) {
+    let updated = false;
     for (const point of outline) {
-      minX = Math.min(minX, point.x);
-      minY = Math.min(minY, point.y);
-      maxX = Math.max(maxX, point.x);
-      maxY = Math.max(maxY, point.y);
+      const x = toNumeric(point.x);
+      const y = toNumeric(point.y);
+      if (x === void 0 || y === void 0) continue;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+      updated = true;
+    }
+    if (updated) {
+      hasBounds = true;
     }
   }
   function updateBoardBoundsToIncludeOutline(outline) {
+    let updated = false;
     for (const point of outline) {
-      boardMinX = Math.min(boardMinX, point.x);
-      boardMinY = Math.min(boardMinY, point.y);
-      boardMaxX = Math.max(boardMaxX, point.x);
-      boardMaxY = Math.max(boardMaxY, point.y);
+      const x = toNumeric(point.x);
+      const y = toNumeric(point.y);
+      if (x === void 0 || y === void 0) continue;
+      boardMinX = Math.min(boardMinX, x);
+      boardMinY = Math.min(boardMinY, y);
+      boardMaxX = Math.max(boardMaxX, x);
+      boardMaxY = Math.max(boardMaxY, y);
+      updated = true;
+    }
+    if (updated) {
+      hasBounds = true;
+      hasBoardBounds = true;
     }
   }
   function updateTraceBounds(route) {
+    let updated = false;
     for (const point of route) {
-      minX = Math.min(minX, point.x);
-      minY = Math.min(minY, point.y);
-      maxX = Math.max(maxX, point.x);
-      maxY = Math.max(maxY, point.y);
+      const x = toNumeric(point?.x);
+      const y = toNumeric(point?.y);
+      if (x === void 0 || y === void 0) continue;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+      updated = true;
+    }
+    if (updated) {
+      hasBounds = true;
     }
   }
   function updateSilkscreenBounds(item) {
@@ -3759,7 +3820,10 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
     } else if (item.type === "pcb_silkscreen_rect") {
       updateBounds(item.center, item.width, item.height);
     } else if (item.type === "pcb_silkscreen_circle") {
-      updateBounds(item.center, item.radius * 2, item.radius * 2);
+      const radius = toNumeric(item.radius);
+      if (radius !== void 0) {
+        updateBounds(item.center, radius * 2, radius * 2);
+      }
     } else if (item.type === "pcb_silkscreen_line") {
       updateBounds({ x: item.x1, y: item.y1 }, 0, 0);
       updateBounds({ x: item.x2, y: item.y2 }, 0, 0);
@@ -3768,7 +3832,10 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
       if (cutout.shape === "rect") {
         updateBounds(cutout.center, cutout.width, cutout.height);
       } else if (cutout.shape === "circle") {
-        updateBounds(cutout.center, cutout.radius * 2, cutout.radius * 2);
+        const radius = toNumeric(cutout.radius);
+        if (radius !== void 0) {
+          updateBounds(cutout.center, radius * 2, radius * 2);
+        }
       } else if (cutout.shape === "polygon") {
         updateTraceBounds(cutout.points);
       }