circuit-to-canvas 0.0.44 → 0.0.46

package/lib/drawer/CircuitToCanvasDrawer.ts

@@ -182,11 +182,7 @@ export class CircuitToCanvasDrawer {
     )
 
     for (const element of elements) {
-      if (
-        element.type === "pcb_board" &&
-        (hasSoldermaskPads || hasSoldermaskHoles || hasSoldermaskPlatedHoles)
-      ) {
-        // Draw board with soldermask fill when pads or holes have soldermask
+      if (element.type === "pcb_board") {
         this.drawBoardWithSoldermask(element as PcbBoard)
       } else {
         this.drawElement(element, options)

package/lib/drawer/elements/pcb-copper-text.ts

@@ -1,13 +1,12 @@
-import type { PcbCopperText } from "circuit-json"
+import type { NinePointAnchor, PcbCopperText } from "circuit-json"
 import type { Matrix } from "transformation-matrix"
 import { applyToPoint } from "transformation-matrix"
-import type { PcbColorMap, CanvasContext } from "../types"
 import {
   getAlphabetLayout,
-  strokeAlphabetText,
   getTextStartPosition,
-  type AnchorAlignment,
+  strokeAlphabetText,
 } from "../shapes/text"
+import type { CanvasContext, PcbColorMap } from "../types"
 
 export interface DrawPcbCopperTextParams {
   ctx: CanvasContext
@@ -18,14 +17,8 @@ export interface DrawPcbCopperTextParams {
 
 const DEFAULT_PADDING = { left: 0.2, right: 0.2, top: 0.2, bottom: 0.2 }
 
-function layerToCopperColor(layer: string, colorMap: PcbColorMap): string {
-  return (
-    colorMap.copper[layer as keyof typeof colorMap.copper] ??
-    colorMap.copper.top
-  )
-}
-
-function mapAnchorAlignment(alignment?: string): AnchorAlignment {
+function mapAnchorAlignment(alignment?: string): NinePointAnchor {
+  // Vertical component is intentionally collapsed to center; callers only care about left/center/right.
   if (!alignment) return "center"
   if (alignment.includes("left")) return "center_left"
   if (alignment.includes("right")) return "center_right"
@@ -49,13 +42,13 @@ export function drawPcbCopperText(params: DrawPcbCopperTextParams): void {
     ...DEFAULT_PADDING,
     ...text.knockout_padding,
   }
-  const textColor = layerToCopperColor(text.layer, colorMap)
+  const textColor =
+    colorMap.copper[text.layer as keyof typeof colorMap.copper] ??
+    colorMap.copper.top
   const layout = getAlphabetLayout(content, fontSize)
   const totalWidth = layout.width + layout.strokeWidth
   const alignment = mapAnchorAlignment(text.anchor_alignment)
   const startPos = getTextStartPosition(alignment, layout)
-  const startX = startPos.x
-  const startY = startPos.y
 
   ctx.save()
   ctx.translate(x, y)
@@ -71,32 +64,25 @@ export function drawPcbCopperText(params: DrawPcbCopperTextParams): void {
     const paddingRight = padding.right * scale
     const paddingTop = padding.top * scale
     const paddingBottom = padding.bottom * scale
-    // Calculate knockout rectangle to cover the text box
-    const textBoxTop = startY - layout.strokeWidth / 2
-    const textBoxBottom = startY + layout.height + layout.strokeWidth / 2
-    const textBoxHeight = textBoxBottom - textBoxTop
-
-    const xOffset = startX - paddingLeft
-    const yOffset = textBoxTop - paddingTop
-    const knockoutWidth = totalWidth + paddingLeft + paddingRight
-    const knockoutHeight = textBoxHeight + paddingTop + paddingBottom
+    const rectX = startPos.x - paddingLeft * 4
+    const rectY = startPos.y - paddingTop * 4
+    const rectWidth = totalWidth + paddingLeft * 2 + paddingRight * 2
+    const rectHeight =
+      layout.height + layout.strokeWidth + paddingTop * 2 + paddingBottom * 2
 
+    // Draw knockout rectangle
     ctx.fillStyle = textColor
-    ctx.fillRect(xOffset, yOffset, knockoutWidth, knockoutHeight)
-
-    const previousCompositeOperation = ctx.globalCompositeOperation
-    ctx.globalCompositeOperation = "destination-out"
-    ctx.fillStyle = "rgba(0,0,0,1)"
-    ctx.strokeStyle = "rgba(0,0,0,1)"
-    strokeAlphabetText({ ctx, text: content, fontSize, startX, startY })
-    if (previousCompositeOperation) {
-      ctx.globalCompositeOperation = previousCompositeOperation
-    } else {
-      ctx.globalCompositeOperation = "source-over"
-    }
+    ctx.fillRect(rectX, rectY, rectWidth, rectHeight)
   } else {
     ctx.strokeStyle = textColor
-    strokeAlphabetText({ ctx, text: content, fontSize, startX, startY })
   }
+
+  strokeAlphabetText({
+    ctx,
+    text: content,
+    fontSize,
+    startX: startPos.x,
+    startY: startPos.y,
+  })
   ctx.restore()
 }

package/lib/drawer/elements/pcb-hole.ts

@@ -5,6 +5,12 @@ import { drawCircle } from "../shapes/circle"
 import { drawRect } from "../shapes/rect"
 import { drawOval } from "../shapes/oval"
 import { drawPill } from "../shapes/pill"
+import {
+  drawSoldermaskRingForCircle,
+  drawSoldermaskRingForOval,
+  drawSoldermaskRingForPill,
+  drawSoldermaskRingForRect,
+} from "./soldermask-margin"
 
 export interface DrawPcbHoleParams {
   ctx: CanvasContext
@@ -24,12 +30,15 @@ function getRotation(hole: PCBHole): number {
 export function drawPcbHole(params: DrawPcbHoleParams): void {
   const { ctx, hole, realToCanvasMat, colorMap } = params
 
+  const isCoveredWithSoldermask = hole.is_covered_with_solder_mask === true
+  const margin = isCoveredWithSoldermask ? 0 : (hole.soldermask_margin ?? 0)
   const hasSoldermask =
-    hole.is_covered_with_solder_mask === true &&
+    !isCoveredWithSoldermask &&
     hole.soldermask_margin !== undefined &&
-    hole.soldermask_margin > 0
-  const margin = hasSoldermask ? hole.soldermask_margin! : 0
+    hole.soldermask_margin !== 0
   const positiveMarginColor = colorMap.substrate
+  const soldermaskOverlayColor = colorMap.soldermask.top
+  const soldermaskRingColor = colorMap.soldermask.top
 
   if (hole.hole_shape === "circle") {
     // For positive margins, draw extended mask area first
@@ -43,14 +52,40 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawCircle({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      radius: hole.hole_diameter / 2,
-      fill: colorMap.drill,
-      realToCanvasMat,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawCircle({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius: hole.hole_diameter / 2,
+        fill: colorMap.drill,
+        realToCanvasMat,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForCircle(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_diameter / 2,
+          margin,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill,
+        )
+      }
+    }
+
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawCircle({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius: hole.hole_diameter / 2,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+      })
+    }
     return
   }
 
@@ -69,16 +104,47 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawRect({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_diameter,
-      height: hole.hole_diameter,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_diameter,
+        height: hole.hole_diameter,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      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 fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_diameter,
+        height: hole.hole_diameter,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation,
+      })
+    }
     return
   }
 
@@ -97,16 +163,46 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    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,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    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,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      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 fully covered, draw soldermask overlay
+    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
   }
 
@@ -125,16 +221,47 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawRect({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      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 fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation,
+      })
+    }
     return
   }
 
@@ -153,16 +280,46 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawPill({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      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 fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation,
+      })
+    }
     return
   }
 
@@ -182,16 +339,46 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawPill({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      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 fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation,
+      })
+    }
     return
   }
 }