circuit-to-canvas 0.0.45 → 0.0.47

package/dist/index.js

@@ -456,6 +456,90 @@ function drawSoldermaskRingForOval(ctx, center, radius_x, radius_y, margin, rota
   }
   ctx.restore();
 }
+function offsetPolygonPoints(points, offset) {
+  if (points.length < 3 || offset === 0) return points;
+  let centerX = 0;
+  let centerY = 0;
+  for (const point of points) {
+    centerX += point.x;
+    centerY += point.y;
+  }
+  centerX /= points.length;
+  centerY /= points.length;
+  const result = [];
+  for (const point of points) {
+    const vectorX = point.x - centerX;
+    const vectorY = point.y - centerY;
+    const distance = Math.sqrt(vectorX * vectorX + vectorY * vectorY);
+    if (distance > 0) {
+      const normalizedX = vectorX / distance;
+      const normalizedY = vectorY / distance;
+      result.push({
+        x: point.x + normalizedX * offset,
+        y: point.y + normalizedY * offset
+      });
+    } else {
+      result.push({
+        x: point.x + offset,
+        y: point.y
+      });
+    }
+  }
+  return result;
+}
+function drawSoldermaskRingForPolygon(ctx, points, margin, realToCanvasMat, soldermaskColor, padColor) {
+  if (points.length < 3 || margin >= 0) return;
+  const scaledMargin = Math.abs(margin) * Math.abs(realToCanvasMat.a);
+  const prevCompositeOp = ctx.globalCompositeOperation;
+  if (ctx.globalCompositeOperation !== void 0) {
+    ctx.globalCompositeOperation = "source-atop";
+  }
+  ctx.beginPath();
+  const canvasPoints = points.map(
+    (p) => applyToPoint6(realToCanvasMat, [p.x, p.y])
+  );
+  const firstPoint = canvasPoints[0];
+  if (firstPoint) {
+    const [firstX, firstY] = firstPoint;
+    ctx.moveTo(firstX, firstY);
+    for (let i = 1; i < canvasPoints.length; i++) {
+      const point = canvasPoints[i];
+      if (point) {
+        const [x, y] = point;
+        ctx.lineTo(x, y);
+      }
+    }
+    ctx.closePath();
+    ctx.fillStyle = soldermaskColor;
+    ctx.fill();
+  }
+  if (ctx.globalCompositeOperation !== void 0) {
+    ctx.globalCompositeOperation = prevCompositeOp || "source-over";
+  }
+  const innerPoints = offsetPolygonPoints(points, margin);
+  if (innerPoints.length >= 3) {
+    ctx.beginPath();
+    const innerCanvasPoints = innerPoints.map(
+      (p) => applyToPoint6(realToCanvasMat, [p.x, p.y])
+    );
+    const firstInnerPoint = innerCanvasPoints[0];
+    if (firstInnerPoint) {
+      const [firstX, firstY] = firstInnerPoint;
+      ctx.moveTo(firstX, firstY);
+      for (let i = 1; i < innerCanvasPoints.length; i++) {
+        const point = innerCanvasPoints[i];
+        if (point) {
+          const [x, y] = point;
+          ctx.lineTo(x, y);
+        }
+      }
+      ctx.closePath();
+      ctx.fillStyle = padColor;
+      ctx.fill();
+    }
+  }
+  ctx.restore();
+}
 
 // lib/drawer/elements/pcb-plated-hole.ts
 function getSoldermaskColor(layers, colorMap) {
@@ -464,8 +548,9 @@ function getSoldermaskColor(layers, colorMap) {
 }
 function drawPcbPlatedHole(params) {
   const { ctx, hole, realToCanvasMat, colorMap } = params;
-  const hasSoldermask = hole.is_covered_with_solder_mask === true && hole.soldermask_margin !== void 0 && hole.soldermask_margin !== 0;
-  const margin = hasSoldermask ? hole.soldermask_margin : 0;
+  const isCoveredWithSoldermask = hole.is_covered_with_solder_mask === true;
+  const margin = isCoveredWithSoldermask ? 0 : hole.soldermask_margin ?? 0;
+  const hasSoldermask = !isCoveredWithSoldermask && hole.soldermask_margin !== void 0 && hole.soldermask_margin !== 0;
   const soldermaskRingColor = getSoldermaskColor(hole.layers, colorMap);
   const positiveMarginColor = colorMap.substrate;
   const copperColor = colorMap.copper.top;
@@ -497,13 +582,24 @@ function drawPcbPlatedHole(params) {
         copperColor
       );
     }
-    drawCircle({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      radius: hole.hole_diameter / 2,
-      fill: colorMap.drill,
-      realToCanvasMat
-    });
+    if (isCoveredWithSoldermask) {
+      drawCircle({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius: hole.outer_diameter / 2,
+        fill: soldermaskRingColor,
+        realToCanvasMat
+      });
+    }
+    if (!isCoveredWithSoldermask) {
+      drawCircle({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius: hole.hole_diameter / 2,
+        fill: colorMap.drill,
+        realToCanvasMat
+      });
+    }
     return;
   }
   if (hole.shape === "oval") {
@@ -540,15 +636,28 @@ function drawPcbPlatedHole(params) {
         copperColor
       );
     }
-    drawOval({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      radius_x: hole.hole_width / 2,
-      radius_y: hole.hole_height / 2,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation: hole.ccw_rotation
-    });
+    if (isCoveredWithSoldermask) {
+      drawOval({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius_x: hole.outer_width / 2,
+        radius_y: hole.outer_height / 2,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+        rotation: hole.ccw_rotation
+      });
+    }
+    if (!isCoveredWithSoldermask) {
+      drawOval({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius_x: hole.hole_width / 2,
+        radius_y: hole.hole_height / 2,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation: hole.ccw_rotation
+      });
+    }
     return;
   }
   if (hole.shape === "pill") {
@@ -585,15 +694,28 @@ function drawPcbPlatedHole(params) {
         copperColor
       );
     }
-    drawPill({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation: hole.ccw_rotation
-    });
+    if (isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.outer_width,
+        height: hole.outer_height,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+        rotation: hole.ccw_rotation
+      });
+    }
+    if (!isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation: hole.ccw_rotation
+      });
+    }
     return;
   }
   if (hole.shape === "circular_hole_with_rect_pad") {
@@ -605,7 +727,7 @@ function drawPcbPlatedHole(params) {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin
+        borderRadius: hole.rect_border_radius ?? 0
       });
     }
     drawRect({
@@ -631,15 +753,28 @@ function drawPcbPlatedHole(params) {
         copperColor
       );
     }
-    const holeX = hole.x + (hole.hole_offset_x ?? 0);
-    const holeY = hole.y + (hole.hole_offset_y ?? 0);
-    drawCircle({
-      ctx,
-      center: { x: holeX, y: holeY },
-      radius: hole.hole_diameter / 2,
-      fill: colorMap.drill,
-      realToCanvasMat
-    });
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.rect_pad_width,
+        height: hole.rect_pad_height,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+        borderRadius: hole.rect_border_radius ?? 0
+      });
+    }
+    if (!isCoveredWithSoldermask) {
+      const holeX = hole.x + (hole.hole_offset_x ?? 0);
+      const holeY = hole.y + (hole.hole_offset_y ?? 0);
+      drawCircle({
+        ctx,
+        center: { x: holeX, y: holeY },
+        radius: hole.hole_diameter / 2,
+        fill: colorMap.drill,
+        realToCanvasMat
+      });
+    }
     return;
   }
   if (hole.shape === "pill_hole_with_rect_pad") {
@@ -651,7 +786,7 @@ function drawPcbPlatedHole(params) {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin
+        borderRadius: hole.rect_border_radius ?? 0
       });
     }
     drawRect({
@@ -677,16 +812,29 @@ function drawPcbPlatedHole(params) {
         copperColor
       );
     }
-    const holeX = hole.x + (hole.hole_offset_x ?? 0);
-    const holeY = hole.y + (hole.hole_offset_y ?? 0);
-    drawPill({
-      ctx,
-      center: { x: holeX, y: holeY },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat
-    });
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.rect_pad_width,
+        height: hole.rect_pad_height,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+        borderRadius: hole.rect_border_radius ?? 0
+      });
+    }
+    if (!isCoveredWithSoldermask) {
+      const holeX = hole.x + (hole.hole_offset_x ?? 0);
+      const holeY = hole.y + (hole.hole_offset_y ?? 0);
+      drawPill({
+        ctx,
+        center: { x: holeX, y: holeY },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat
+      });
+    }
     return;
   }
   if (hole.shape === "rotated_pill_hole_with_rect_pad") {
@@ -698,7 +846,7 @@ function drawPcbPlatedHole(params) {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin,
+        borderRadius: hole.rect_border_radius ?? 0,
         rotation: hole.rect_ccw_rotation
       });
     }
@@ -726,17 +874,31 @@ function drawPcbPlatedHole(params) {
         copperColor
       );
     }
-    const holeX = hole.x + (hole.hole_offset_x ?? 0);
-    const holeY = hole.y + (hole.hole_offset_y ?? 0);
-    drawPill({
-      ctx,
-      center: { x: holeX, y: holeY },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation: hole.hole_ccw_rotation
-    });
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.rect_pad_width,
+        height: hole.rect_pad_height,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+        borderRadius: hole.rect_border_radius ?? 0,
+        rotation: hole.rect_ccw_rotation
+      });
+    }
+    if (!isCoveredWithSoldermask) {
+      const holeX = hole.x + (hole.hole_offset_x ?? 0);
+      const holeY = hole.y + (hole.hole_offset_y ?? 0);
+      drawPill({
+        ctx,
+        center: { x: holeX, y: holeY },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation: hole.hole_ccw_rotation
+      });
+    }
     return;
   }
   if (hole.shape === "hole_with_polygon_pad") {
@@ -746,51 +908,80 @@ function drawPcbPlatedHole(params) {
         x: hole.x + point.x,
         y: hole.y + point.y
       }));
+      if (hasSoldermask && margin > 0) {
+        const expandedPoints = offsetPolygonPoints(padPoints, margin);
+        drawPolygon({
+          ctx,
+          points: expandedPoints,
+          fill: positiveMarginColor,
+          realToCanvasMat
+        });
+      }
       drawPolygon({
         ctx,
         points: padPoints,
         fill: copperColor,
         realToCanvasMat
       });
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPolygon(
+          ctx,
+          padPoints,
+          margin,
+          realToCanvasMat,
+          soldermaskRingColor,
+          copperColor
+        );
+      }
+      if (isCoveredWithSoldermask) {
+        drawPolygon({
+          ctx,
+          points: padPoints,
+          fill: soldermaskRingColor,
+          realToCanvasMat
+        });
+      }
     }
-    const holeX = hole.x + (hole.hole_offset_x ?? 0);
-    const holeY = hole.y + (hole.hole_offset_y ?? 0);
-    const holeShape = hole.hole_shape;
-    if (holeShape === "circle") {
-      drawCircle({
-        ctx,
-        center: { x: holeX, y: holeY },
-        radius: (hole.hole_diameter ?? 0) / 2,
-        fill: colorMap.drill,
-        realToCanvasMat
-      });
-    } else if (holeShape === "oval") {
-      drawOval({
-        ctx,
-        center: { x: holeX, y: holeY },
-        radius_x: (hole.hole_width ?? 0) / 2,
-        radius_y: (hole.hole_height ?? 0) / 2,
-        fill: colorMap.drill,
-        realToCanvasMat
-      });
-    } else if (holeShape === "pill") {
-      drawPill({
-        ctx,
-        center: { x: holeX, y: holeY },
-        width: hole.hole_width ?? 0,
-        height: hole.hole_height ?? 0,
-        fill: colorMap.drill,
-        realToCanvasMat
-      });
-    } else if (holeShape === "rotated_pill") {
-      drawPill({
-        ctx,
-        center: { x: holeX, y: holeY },
-        width: hole.hole_width ?? 0,
-        height: hole.hole_height ?? 0,
-        fill: colorMap.drill,
-        realToCanvasMat
-      });
+    if (!isCoveredWithSoldermask) {
+      const holeX = hole.x + (hole.hole_offset_x ?? 0);
+      const holeY = hole.y + (hole.hole_offset_y ?? 0);
+      const holeShape = hole.hole_shape;
+      if (holeShape === "circle") {
+        drawCircle({
+          ctx,
+          center: { x: holeX, y: holeY },
+          radius: (hole.hole_diameter ?? 0) / 2,
+          fill: colorMap.drill,
+          realToCanvasMat
+        });
+      } else if (holeShape === "oval") {
+        drawOval({
+          ctx,
+          center: { x: holeX, y: holeY },
+          radius_x: (hole.hole_width ?? 0) / 2,
+          radius_y: (hole.hole_height ?? 0) / 2,
+          fill: colorMap.drill,
+          realToCanvasMat
+        });
+      } else if (holeShape === "pill") {
+        drawPill({
+          ctx,
+          center: { x: holeX, y: holeY },
+          width: hole.hole_width ?? 0,
+          height: hole.hole_height ?? 0,
+          fill: colorMap.drill,
+          realToCanvasMat
+        });
+      } else if (holeShape === "rotated_pill") {
+        drawPill({
+          ctx,
+          center: { x: holeX, y: holeY },
+          width: hole.hole_width ?? 0,
+          height: hole.hole_height ?? 0,
+          fill: colorMap.drill,
+          realToCanvasMat
+        });
+      }
     }
     return;
   }
@@ -824,9 +1015,12 @@ function getRotation(hole) {
 }
 function drawPcbHole(params) {
   const { ctx, hole, realToCanvasMat, colorMap } = params;
-  const hasSoldermask = hole.is_covered_with_solder_mask === true && hole.soldermask_margin !== void 0 && hole.soldermask_margin > 0;
-  const margin = hasSoldermask ? hole.soldermask_margin : 0;
+  const isCoveredWithSoldermask = hole.is_covered_with_solder_mask === true;
+  const margin = isCoveredWithSoldermask ? 0 : hole.soldermask_margin ?? 0;
+  const hasSoldermask = !isCoveredWithSoldermask && hole.soldermask_margin !== void 0 && hole.soldermask_margin !== 0;
   const positiveMarginColor = colorMap.substrate;
+  const soldermaskOverlayColor = colorMap.soldermask.top;
+  const soldermaskRingColor = colorMap.soldermask.top;
   if (hole.hole_shape === "circle") {
     if (hasSoldermask && margin > 0) {
       drawCircle({
@@ -837,13 +1031,35 @@ function drawPcbHole(params) {
         realToCanvasMat
       });
     }
-    drawCircle({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      radius: hole.hole_diameter / 2,
-      fill: colorMap.drill,
-      realToCanvasMat
-    });
+    if (!isCoveredWithSoldermask) {
+      drawCircle({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius: hole.hole_diameter / 2,
+        fill: colorMap.drill,
+        realToCanvasMat
+      });
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForCircle(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_diameter / 2,
+          margin,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill
+        );
+      }
+    }
+    if (isCoveredWithSoldermask) {
+      drawCircle({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius: hole.hole_diameter / 2,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat
+      });
+    }
     return;
   }
   if (hole.hole_shape === "square") {
@@ -859,15 +1075,42 @@ function drawPcbHole(params) {
         rotation
       });
     }
-    drawRect({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_diameter,
-      height: hole.hole_diameter,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation
-    });
+    if (!isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_diameter,
+        height: hole.hole_diameter,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation
+      });
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForRect(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_diameter,
+          hole.hole_diameter,
+          margin,
+          0,
+          rotation,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill
+        );
+      }
+    }
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_diameter,
+        height: hole.hole_diameter,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation
+      });
+    }
     return;
   }
   if (hole.hole_shape === "oval") {
@@ -883,15 +1126,41 @@ function drawPcbHole(params) {
         rotation
       });
     }
-    drawOval({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      radius_x: hole.hole_width / 2,
-      radius_y: hole.hole_height / 2,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation
-    });
+    if (!isCoveredWithSoldermask) {
+      drawOval({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius_x: hole.hole_width / 2,
+        radius_y: hole.hole_height / 2,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation
+      });
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForOval(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_width / 2,
+          hole.hole_height / 2,
+          margin,
+          rotation,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill
+        );
+      }
+    }
+    if (isCoveredWithSoldermask) {
+      drawOval({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius_x: hole.hole_width / 2,
+        radius_y: hole.hole_height / 2,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation
+      });
+    }
     return;
   }
   if (hole.hole_shape === "rect") {
@@ -907,15 +1176,42 @@ function drawPcbHole(params) {
         rotation
       });
     }
-    drawRect({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation
-    });
+    if (!isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation
+      });
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForRect(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_width,
+          hole.hole_height,
+          margin,
+          0,
+          rotation,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill
+        );
+      }
+    }
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation
+      });
+    }
     return;
   }
   if (hole.hole_shape === "pill") {
@@ -931,15 +1227,41 @@ function drawPcbHole(params) {
         rotation
       });
     }
-    drawPill({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation
-    });
+    if (!isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation
+      });
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPill(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_width,
+          hole.hole_height,
+          margin,
+          rotation,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill
+        );
+      }
+    }
+    if (isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation
+      });
+    }
     return;
   }
   if (hole.hole_shape === "rotated_pill") {
@@ -955,15 +1277,41 @@ function drawPcbHole(params) {
         rotation
       });
     }
-    drawPill({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation
-    });
+    if (!isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation
+      });
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPill(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_width,
+          hole.hole_height,
+          margin,
+          rotation,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill
+        );
+      }
+    }
+    if (isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation
+      });
+    }
     return;
   }
 }
@@ -982,13 +1330,13 @@ function drawPcbSmtPad(params) {
   const { ctx, pad, realToCanvasMat, colorMap } = params;
   const color = layerToColor(pad.layer, colorMap);
   const isCoveredWithSoldermask = pad.is_covered_with_solder_mask === true;
-  const margin = isCoveredWithSoldermask && pad.soldermask_margin !== void 0 ? pad.soldermask_margin : 0;
-  const hasSoldermask = isCoveredWithSoldermask && pad.soldermask_margin !== void 0 && pad.soldermask_margin !== 0;
+  const margin = isCoveredWithSoldermask ? 0 : pad.soldermask_margin ?? 0;
+  const hasSoldermask = !isCoveredWithSoldermask && pad.soldermask_margin !== void 0 && pad.soldermask_margin !== 0;
   const soldermaskRingColor = getSoldermaskColor2(pad.layer, colorMap);
   const positiveMarginColor = colorMap.substrate;
   const soldermaskOverlayColor = getSoldermaskColor2(pad.layer, colorMap);
   if (pad.shape === "rect") {
-    if (isCoveredWithSoldermask && margin >= 0) {
+    if (hasSoldermask && margin > 0) {
       drawRect({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -996,7 +1344,7 @@ function drawPcbSmtPad(params) {
         height: pad.height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: getBorderRadius(pad, margin)
+        borderRadius: getBorderRadius(pad)
       });
     }
     drawRect({
@@ -1036,7 +1384,7 @@ function drawPcbSmtPad(params) {
     return;
   }
   if (pad.shape === "rotated_rect") {
-    if (isCoveredWithSoldermask && margin >= 0) {
+    if (hasSoldermask && margin > 0) {
       drawRect({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -1044,7 +1392,7 @@ function drawPcbSmtPad(params) {
         height: pad.height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: getBorderRadius(pad, margin),
+        borderRadius: getBorderRadius(pad),
         rotation: pad.ccw_rotation ?? 0
       });
     }
@@ -1087,7 +1435,7 @@ function drawPcbSmtPad(params) {
     return;
   }
   if (pad.shape === "circle") {
-    if (isCoveredWithSoldermask && margin >= 0) {
+    if (hasSoldermask && margin > 0) {
       drawCircle({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -1126,7 +1474,7 @@ function drawPcbSmtPad(params) {
     return;
   }
   if (pad.shape === "pill") {
-    if (isCoveredWithSoldermask && margin >= 0) {
+    if (hasSoldermask && margin > 0) {
       drawPill({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -1170,7 +1518,7 @@ function drawPcbSmtPad(params) {
     return;
   }
   if (pad.shape === "rotated_pill") {
-    if (isCoveredWithSoldermask && margin >= 0) {
+    if (hasSoldermask && margin > 0) {
       drawPill({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -1218,13 +1566,32 @@ function drawPcbSmtPad(params) {
   }
   if (pad.shape === "polygon") {
     if (pad.points && pad.points.length >= 3) {
+      if (hasSoldermask && margin > 0) {
+        const expandedPoints = offsetPolygonPoints(pad.points, margin);
+        drawPolygon({
+          ctx,
+          points: expandedPoints,
+          fill: positiveMarginColor,
+          realToCanvasMat
+        });
+      }
       drawPolygon({
         ctx,
         points: pad.points,
         fill: color,
         realToCanvasMat
       });
-      if (isCoveredWithSoldermask && margin >= 0) {
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPolygon(
+          ctx,
+          pad.points,
+          margin,
+          realToCanvasMat,
+          soldermaskRingColor,
+          color
+        );
+      }
+      if (isCoveredWithSoldermask && margin === 0) {
         drawPolygon({
           ctx,
           points: pad.points,
@@ -2355,7 +2722,7 @@ var CircuitToCanvasDrawer = class {
       (el) => el.type === "pcb_plated_hole" && el.is_covered_with_solder_mask === true
     );
     for (const element of elements) {
-      if (element.type === "pcb_board" && (hasSoldermaskPads || hasSoldermaskHoles || hasSoldermaskPlatedHoles)) {
+      if (element.type === "pcb_board") {
         this.drawBoardWithSoldermask(element);
       } else {
         this.drawElement(element, options);