circuit-to-canvas 0.0.31 → 0.0.33

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AnyCircuitElement, PcbRenderLayer, NinePointAnchor, PcbPlatedHole, PCBVia, PCBHole, PcbSmtPad, PCBTrace, PcbBoard, PcbSilkscreenText, PcbSilkscreenRect, PcbSilkscreenCircle, PcbSilkscreenLine, PcbSilkscreenPath, PcbSilkscreenPill, PcbCutout, PcbCopperPour, PcbCopperText, PcbFabricationNoteText, PcbFabricationNoteRect, PcbNoteRect, PcbFabricationNotePath, PcbNotePath, PcbNoteText, PcbNoteDimension } from 'circuit-json';
+import { AnyCircuitElement, PcbRenderLayer, NinePointAnchor, PcbPlatedHole, PCBVia, PCBHole, PcbSmtPad, PCBTrace, PcbBoard, PcbSilkscreenText, PcbSilkscreenRect, PcbSilkscreenCircle, PcbSilkscreenLine, PcbSilkscreenPath, PcbSilkscreenPill, PcbSilkscreenOval, PcbCutout, PcbCopperPour, PcbCopperText, PcbFabricationNoteText, PcbFabricationNoteRect, PcbNoteRect, PcbFabricationNotePath, PcbNotePath, PcbNoteText, PcbNoteDimension, PcbFabricationNoteDimension } from 'circuit-json';
 import { Matrix } from 'transformation-matrix';
 
 /**
@@ -139,9 +139,11 @@ interface DrawOvalParams {
         x: number;
         y: number;
     };
-    width: number;
-    height: number;
-    fill: string;
+    radius_x: number;
+    radius_y: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
     realToCanvasMat: Matrix;
     rotation?: number;
 }
@@ -219,6 +221,33 @@ interface DrawArrowParams {
  */
 declare function drawArrow(params: DrawArrowParams): void;
 
+interface DrawDimensionLineParams {
+    ctx: CanvasContext;
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+    realToCanvasMat: Matrix;
+    color: string;
+    fontSize: number;
+    arrowSize?: number;
+    strokeWidth?: number;
+    text?: string;
+    textRotation?: number;
+    offset?: {
+        distance: number;
+        direction: {
+            x: number;
+            y: number;
+        };
+    };
+}
+declare function drawDimensionLine(params: DrawDimensionLineParams): void;
+
 interface StrokeAlphabetTextParams {
     ctx: CanvasContext;
     text: string;
@@ -377,6 +406,14 @@ interface DrawPcbSilkscreenPillParams {
 }
 declare function drawPcbSilkscreenPill(params: DrawPcbSilkscreenPillParams): void;
 
+interface DrawPcbSilkscreenOvalParams {
+    ctx: CanvasContext;
+    oval: PcbSilkscreenOval;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap;
+}
+declare function drawPcbSilkscreenOval(params: DrawPcbSilkscreenOvalParams): void;
+
 interface DrawPcbCutoutParams {
     ctx: CanvasContext;
     cutout: PcbCutout;
@@ -457,4 +494,12 @@ interface DrawPcbNoteDimensionParams {
 }
 declare function drawPcbNoteDimension(params: DrawPcbNoteDimensionParams): void;
 
-export { type AlphabetLayout, type AnchorAlignment, type CameraBounds, type CanvasContext, CircuitToCanvasDrawer, type CopperColorMap, type CopperLayerName, DEFAULT_PCB_COLOR_MAP, type DrawArrowParams, type DrawCircleParams, type DrawContext, type DrawElementsOptions, type DrawLineParams, type DrawOvalParams, type DrawPathParams, type DrawPcbBoardParams, type DrawPcbCopperPourParams, type DrawPcbCopperTextParams, type DrawPcbCutoutParams, type DrawPcbFabricationNotePathParams, type DrawPcbFabricationNoteRectParams, type DrawPcbFabricationNoteTextParams, type DrawPcbHoleParams, type DrawPcbNoteDimensionParams, type DrawPcbNotePathParams, type DrawPcbNoteRectParams, type DrawPcbNoteTextParams, type DrawPcbPlatedHoleParams, type DrawPcbSilkscreenCircleParams, type DrawPcbSilkscreenLineParams, type DrawPcbSilkscreenPathParams, type DrawPcbSilkscreenPillParams, type DrawPcbSilkscreenRectParams, type DrawPcbSilkscreenTextParams, type DrawPcbSmtPadParams, type DrawPcbTraceParams, type DrawPcbViaParams, type DrawPillParams, type DrawPolygonParams, type DrawRectParams, type DrawTextParams, type DrawerConfig, type PcbColorMap, drawArrow, drawCircle, drawLine, drawOval, drawPath, drawPcbBoard, drawPcbCopperPour, drawPcbCopperText, drawPcbCutout, drawPcbFabricationNotePath, drawPcbFabricationNoteRect, drawPcbFabricationNoteText, drawPcbHole, drawPcbNoteDimension, drawPcbNotePath, drawPcbNoteRect, drawPcbNoteText, drawPcbPlatedHole, drawPcbSilkscreenCircle, drawPcbSilkscreenLine, drawPcbSilkscreenPath, drawPcbSilkscreenPill, drawPcbSilkscreenRect, drawPcbSilkscreenText, drawPcbSmtPad, drawPcbTrace, drawPcbVia, drawPill, drawPolygon, drawRect, drawSoldermaskRingForCircle, drawSoldermaskRingForPill, drawSoldermaskRingForRect, drawText, getAlphabetLayout, getTextStartPosition, strokeAlphabetText };
+interface DrawPcbFabricationNoteDimensionParams {
+    ctx: CanvasContext;
+    pcbFabricationNoteDimension: PcbFabricationNoteDimension;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap;
+}
+declare function drawPcbFabricationNoteDimension(params: DrawPcbFabricationNoteDimensionParams): void;
+
+export { type AlphabetLayout, type AnchorAlignment, type CameraBounds, type CanvasContext, CircuitToCanvasDrawer, type CopperColorMap, type CopperLayerName, DEFAULT_PCB_COLOR_MAP, type DrawArrowParams, type DrawCircleParams, type DrawContext, type DrawDimensionLineParams, type DrawElementsOptions, type DrawLineParams, type DrawOvalParams, type DrawPathParams, type DrawPcbBoardParams, type DrawPcbCopperPourParams, type DrawPcbCopperTextParams, type DrawPcbCutoutParams, type DrawPcbFabricationNoteDimensionParams, type DrawPcbFabricationNotePathParams, type DrawPcbFabricationNoteRectParams, type DrawPcbFabricationNoteTextParams, type DrawPcbHoleParams, type DrawPcbNoteDimensionParams, type DrawPcbNotePathParams, type DrawPcbNoteRectParams, type DrawPcbNoteTextParams, type DrawPcbPlatedHoleParams, type DrawPcbSilkscreenCircleParams, type DrawPcbSilkscreenLineParams, type DrawPcbSilkscreenOvalParams, type DrawPcbSilkscreenPathParams, type DrawPcbSilkscreenPillParams, type DrawPcbSilkscreenRectParams, type DrawPcbSilkscreenTextParams, type DrawPcbSmtPadParams, type DrawPcbTraceParams, type DrawPcbViaParams, type DrawPillParams, type DrawPolygonParams, type DrawRectParams, type DrawTextParams, type DrawerConfig, type PcbColorMap, drawArrow, drawCircle, drawDimensionLine, drawLine, drawOval, drawPath, drawPcbBoard, drawPcbCopperPour, drawPcbCopperText, drawPcbCutout, drawPcbFabricationNoteDimension, drawPcbFabricationNotePath, drawPcbFabricationNoteRect, drawPcbFabricationNoteText, drawPcbHole, drawPcbNoteDimension, drawPcbNotePath, drawPcbNoteRect, drawPcbNoteText, drawPcbPlatedHole, drawPcbSilkscreenCircle, drawPcbSilkscreenLine, drawPcbSilkscreenOval, drawPcbSilkscreenPath, drawPcbSilkscreenPill, drawPcbSilkscreenRect, drawPcbSilkscreenText, drawPcbSmtPad, drawPcbTrace, drawPcbVia, drawPill, drawPolygon, drawRect, drawSoldermaskRingForCircle, drawSoldermaskRingForPill, drawSoldermaskRingForRect, drawText, getAlphabetLayout, getTextStartPosition, strokeAlphabetText };

package/dist/index.js

@@ -138,24 +138,34 @@ function drawOval(params) {
   const {
     ctx,
     center,
-    width,
-    height,
+    radius_x,
+    radius_y,
     fill,
+    stroke,
+    strokeWidth = 0.1,
     realToCanvasMat,
     rotation = 0
   } = params;
   const [cx, cy] = applyToPoint3(realToCanvasMat, [center.x, center.y]);
-  const scaledWidth = width * Math.abs(realToCanvasMat.a);
-  const scaledHeight = height * Math.abs(realToCanvasMat.a);
+  const scaledRadiusX = radius_x * Math.abs(realToCanvasMat.a);
+  const scaledRadiusY = radius_y * Math.abs(realToCanvasMat.a);
+  const scaledStrokeWidth = strokeWidth * Math.abs(realToCanvasMat.a);
   ctx.save();
   ctx.translate(cx, cy);
   if (rotation !== 0) {
     ctx.rotate(-rotation * (Math.PI / 180));
   }
   ctx.beginPath();
-  ctx.ellipse(0, 0, scaledWidth / 2, scaledHeight / 2, 0, 0, Math.PI * 2);
-  ctx.fillStyle = fill;
-  ctx.fill();
+  ctx.ellipse(0, 0, scaledRadiusX, scaledRadiusY, 0, 0, Math.PI * 2);
+  if (fill) {
+    ctx.fillStyle = fill;
+    ctx.fill();
+  }
+  if (stroke) {
+    ctx.strokeStyle = stroke;
+    ctx.lineWidth = scaledStrokeWidth;
+    ctx.stroke();
+  }
   ctx.restore();
 }
 
@@ -263,8 +273,8 @@ function drawPcbPlatedHole(params) {
     drawOval({
       ctx,
       center: { x: hole.x, y: hole.y },
-      width: hole.outer_width,
-      height: hole.outer_height,
+      radius_x: hole.outer_width / 2,
+      radius_y: hole.outer_height / 2,
       fill: colorMap.copper.top,
       realToCanvasMat,
       rotation: hole.ccw_rotation
@@ -272,8 +282,8 @@ function drawPcbPlatedHole(params) {
     drawOval({
       ctx,
       center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
+      radius_x: hole.hole_width / 2,
+      radius_y: hole.hole_height / 2,
       fill: colorMap.drill,
       realToCanvasMat,
       rotation: hole.ccw_rotation
@@ -397,8 +407,8 @@ function drawPcbPlatedHole(params) {
       drawOval({
         ctx,
         center: { x: holeX, y: holeY },
-        width: hole.hole_width ?? 0,
-        height: hole.hole_height ?? 0,
+        radius_x: (hole.hole_width ?? 0) / 2,
+        radius_y: (hole.hole_height ?? 0) / 2,
         fill: colorMap.drill,
         realToCanvasMat
       });
@@ -472,8 +482,8 @@ function drawPcbHole(params) {
     drawOval({
       ctx,
       center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
+      radius_x: hole.hole_width / 2,
+      radius_y: hole.hole_height / 2,
       fill: colorMap.drill,
       realToCanvasMat
     });
@@ -1275,13 +1285,32 @@ function drawPcbSilkscreenPath(params) {
   }
 }
 
-// lib/drawer/elements/pcb-silkscreen-pill.ts
+// lib/drawer/elements/pcb-silkscreen-oval.ts
 function layerToSilkscreenColor6(layer, colorMap) {
   return layer === "bottom" ? colorMap.silkscreen.bottom : colorMap.silkscreen.top;
 }
+function drawPcbSilkscreenOval(params) {
+  const { ctx, oval, realToCanvasMat, colorMap } = params;
+  const color = layerToSilkscreenColor6(oval.layer, colorMap);
+  drawOval({
+    ctx,
+    center: oval.center,
+    radius_x: oval.radius_x,
+    radius_y: oval.radius_y,
+    stroke: color,
+    strokeWidth: 0.1,
+    realToCanvasMat,
+    rotation: oval.ccw_rotation ?? 0
+  });
+}
+
+// lib/drawer/elements/pcb-silkscreen-pill.ts
+function layerToSilkscreenColor7(layer, colorMap) {
+  return layer === "bottom" ? colorMap.silkscreen.bottom : colorMap.silkscreen.top;
+}
 function drawPcbSilkscreenPill(params) {
   const { ctx, pill, realToCanvasMat, colorMap } = params;
-  const color = layerToSilkscreenColor6(pill.layer, colorMap);
+  const color = layerToSilkscreenColor7(pill.layer, colorMap);
   const strokeWidth = 0.2;
   drawPill({
     ctx,
@@ -1589,7 +1618,7 @@ function drawPcbNoteText(params) {
   });
 }
 
-// lib/drawer/elements/pcb-note-dimension.ts
+// lib/drawer/shapes/dimension-line.ts
 import { applyToPoint as applyToPoint13 } from "transformation-matrix";
 
 // lib/drawer/shapes/arrow.ts
@@ -1611,134 +1640,208 @@ function drawArrow(params) {
   ctx.restore();
 }
 
-// lib/drawer/elements/pcb-note-dimension.ts
-var DEFAULT_NOTE_COLOR = "rgba(255,255,255,0.5)";
-function drawPcbNoteDimension(params) {
-  const { ctx, pcbNoteDimension, realToCanvasMat } = params;
-  const color = pcbNoteDimension.color ?? DEFAULT_NOTE_COLOR;
-  const arrowSize = pcbNoteDimension.arrow_size;
-  const realFromX = pcbNoteDimension.from.x;
-  const realFromY = pcbNoteDimension.from.y;
-  const realToX = pcbNoteDimension.to.x;
-  const realToY = pcbNoteDimension.to.y;
-  let fromX = realFromX;
-  let fromY = realFromY;
-  let toX = realToX;
-  let toY = realToY;
-  let hasOffset = false;
-  let offsetX = 0;
-  let offsetY = 0;
-  if (pcbNoteDimension.offset_distance && pcbNoteDimension.offset_direction) {
-    const dirX = pcbNoteDimension.offset_direction.x;
-    const dirY = pcbNoteDimension.offset_direction.y;
-    const length = Math.hypot(dirX, dirY);
-    if (length > 0) {
-      const normX = dirX / length;
-      const normY = dirY / length;
-      hasOffset = true;
-      offsetX = pcbNoteDimension.offset_distance * normX;
-      offsetY = pcbNoteDimension.offset_distance * normY;
-      fromX += offsetX;
-      fromY += offsetY;
-      toX += offsetX;
-      toY += offsetY;
-    }
-  }
-  const STROKE_WIDTH_RATIO2 = 0.13;
-  const strokeWidth = Math.max(
-    pcbNoteDimension.font_size * STROKE_WIDTH_RATIO2,
-    0.35
-  );
-  if (hasOffset) {
-    drawLine({
-      ctx,
-      start: { x: realFromX, y: realFromY },
-      end: { x: fromX, y: fromY },
-      strokeWidth,
-      stroke: color,
-      realToCanvasMat
-    });
+// lib/drawer/shapes/dimension-line.ts
+var TEXT_OFFSET_MULTIPLIER = 1.5;
+var CHARACTER_WIDTH_MULTIPLIER = 0.6;
+var TEXT_INTERSECTION_PADDING_MULTIPLIER = 0.3;
+function normalize(v) {
+  const len = Math.hypot(v.x, v.y) || 1;
+  return { x: v.x / len, y: v.y / len };
+}
+function drawDimensionLine(params) {
+  const {
+    ctx,
+    from,
+    to,
+    realToCanvasMat,
+    color,
+    fontSize,
+    arrowSize = 1,
+    strokeWidth: manualStrokeWidth,
+    text,
+    textRotation,
+    offset
+  } = params;
+  const direction = normalize({ x: to.x - from.x, y: to.y - from.y });
+  const perpendicular = { x: -direction.y, y: direction.x };
+  const hasOffsetDirection = offset?.direction && typeof offset.direction.x === "number" && typeof offset.direction.y === "number";
+  const normalizedOffsetDirection = hasOffsetDirection ? normalize(offset.direction) : { x: 0, y: 0 };
+  const offsetMagnitude = offset?.distance ?? 0;
+  const offsetVector = {
+    x: normalizedOffsetDirection.x * offsetMagnitude,
+    y: normalizedOffsetDirection.y * offsetMagnitude
+  };
+  const fromOffset = { x: from.x + offsetVector.x, y: from.y + offsetVector.y };
+  const toOffset = { x: to.x + offsetVector.x, y: to.y + offsetVector.y };
+  const fromBase = {
+    x: fromOffset.x + direction.x * arrowSize,
+    y: fromOffset.y + direction.y * arrowSize
+  };
+  const toBase = {
+    x: toOffset.x - direction.x * arrowSize,
+    y: toOffset.y - direction.y * arrowSize
+  };
+  const scaleValue = Math.abs(realToCanvasMat.a);
+  const strokeWidth = manualStrokeWidth ?? arrowSize / 5;
+  const lineColor = color || "rgba(255,255,255,0.5)";
+  const extensionDirection = hasOffsetDirection && (Math.abs(normalizedOffsetDirection.x) > Number.EPSILON || Math.abs(normalizedOffsetDirection.y) > Number.EPSILON) ? normalizedOffsetDirection : perpendicular;
+  const extensionLength = offsetMagnitude + 0.5;
+  const drawExtension = (anchor) => {
+    const endPoint = {
+      x: anchor.x + extensionDirection.x * extensionLength,
+      y: anchor.y + extensionDirection.y * extensionLength
+    };
     drawLine({
       ctx,
-      start: { x: realToX, y: realToY },
-      end: { x: toX, y: toY },
+      start: anchor,
+      end: endPoint,
       strokeWidth,
-      stroke: color,
+      stroke: lineColor,
       realToCanvasMat
     });
-  }
+  };
+  drawExtension(from);
+  drawExtension(to);
   drawLine({
     ctx,
-    start: { x: fromX, y: fromY },
-    end: { x: toX, y: toY },
+    start: fromBase,
+    end: toBase,
     strokeWidth,
-    stroke: color,
+    stroke: lineColor,
     realToCanvasMat
   });
   const [canvasFromX, canvasFromY] = applyToPoint13(realToCanvasMat, [
-    fromX,
-    fromY
+    fromOffset.x,
+    fromOffset.y
   ]);
-  const [canvasToX, canvasToY] = applyToPoint13(realToCanvasMat, [toX, toY]);
-  const canvasDx = canvasToX - canvasFromX;
-  const canvasDy = canvasToY - canvasFromY;
-  const lineAngle = Math.atan2(canvasDy, canvasDx);
-  const scale2 = Math.abs(realToCanvasMat.a);
-  const scaledArrowSize = arrowSize * scale2;
-  const scaledStrokeWidth = strokeWidth * scale2;
+  const [canvasToX, canvasToY] = applyToPoint13(realToCanvasMat, [
+    toOffset.x,
+    toOffset.y
+  ]);
+  const [canvasToDirX, canvasToDirY] = applyToPoint13(realToCanvasMat, [
+    toOffset.x + direction.x,
+    toOffset.y + direction.y
+  ]);
+  const canvasLineAngle = Math.atan2(
+    canvasToDirY - canvasToY,
+    canvasToDirX - canvasToX
+  );
   drawArrow({
     ctx,
     x: canvasFromX,
     y: canvasFromY,
-    angle: lineAngle + Math.PI,
-    arrowSize: scaledArrowSize,
-    color,
-    strokeWidth: scaledStrokeWidth
+    angle: canvasLineAngle + Math.PI,
+    arrowSize: arrowSize * scaleValue,
+    color: lineColor,
+    strokeWidth: strokeWidth * scaleValue
   });
   drawArrow({
     ctx,
     x: canvasToX,
     y: canvasToY,
-    angle: lineAngle,
-    arrowSize: scaledArrowSize,
-    color,
-    strokeWidth: scaledStrokeWidth
+    angle: canvasLineAngle,
+    arrowSize: arrowSize * scaleValue,
+    color: lineColor,
+    strokeWidth: strokeWidth * scaleValue
   });
-  if (pcbNoteDimension.text) {
-    let textX = (fromX + toX) / 2;
-    let textY = (fromY + toY) / 2;
-    const perpX = toY - fromY;
-    const perpY = -(toX - fromX);
-    const perpLength = Math.sqrt(perpX * perpX + perpY * perpY);
-    if (perpLength > 0) {
-      const offsetDistance = pcbNoteDimension.font_size * 1.5;
-      const normalizedPerpX = perpX / perpLength;
-      const normalizedPerpY = perpY / perpLength;
-      textX += normalizedPerpX * offsetDistance;
-      textY += normalizedPerpY * offsetDistance;
+  if (text) {
+    const midPoint = {
+      x: (from.x + to.x) / 2 + offsetVector.x,
+      y: (from.y + to.y) / 2 + offsetVector.y
+    };
+    const [screenFromX, screenFromY] = applyToPoint13(realToCanvasMat, [
+      fromOffset.x,
+      fromOffset.y
+    ]);
+    const [screenToX, screenToY] = applyToPoint13(realToCanvasMat, [
+      toOffset.x,
+      toOffset.y
+    ]);
+    const screenDirection = normalize({
+      x: screenToX - screenFromX,
+      y: screenToY - screenFromY
+    });
+    let textAngle = Math.atan2(screenDirection.y, screenDirection.x) * 180 / Math.PI;
+    if (textAngle > 90 || textAngle < -90) {
+      textAngle += 180;
     }
-    const textRotation = -(() => {
-      const raw = pcbNoteDimension.text_ccw_rotation ?? lineAngle * 180 / Math.PI;
-      if (pcbNoteDimension.text_ccw_rotation !== void 0) return raw;
-      let deg = (raw + 180) % 360 - 180;
-      if (deg > 90) deg -= 180;
-      if (deg < -90) deg += 180;
-      return deg;
-    })();
+    const finalTextAngle = typeof textRotation === "number" && Number.isFinite(textRotation) ? textAngle - textRotation : textAngle;
+    let additionalOffset = 0;
+    if (text && typeof textRotation === "number" && Number.isFinite(textRotation)) {
+      const textWidth = text.length * fontSize * CHARACTER_WIDTH_MULTIPLIER;
+      const textHeight = fontSize;
+      const rotationRad = textRotation * Math.PI / 180;
+      const sinRot = Math.abs(Math.sin(rotationRad));
+      const cosRot = Math.abs(Math.cos(rotationRad));
+      const halfWidth = textWidth / 2;
+      const halfHeight = textHeight / 2;
+      const maxExtension = halfWidth * sinRot + halfHeight * cosRot;
+      additionalOffset = maxExtension + fontSize * TEXT_INTERSECTION_PADDING_MULTIPLIER;
+    }
+    const textOffset = arrowSize * TEXT_OFFSET_MULTIPLIER + additionalOffset;
+    const textPoint = {
+      x: midPoint.x + perpendicular.x * textOffset,
+      y: midPoint.y + perpendicular.y * textOffset
+    };
     drawText({
       ctx,
-      text: pcbNoteDimension.text,
-      x: textX,
-      y: textY,
-      fontSize: pcbNoteDimension.font_size,
-      color,
+      text,
+      x: textPoint.x,
+      y: textPoint.y,
+      fontSize,
+      color: lineColor,
       realToCanvasMat,
       anchorAlignment: "center",
-      rotation: textRotation
+      rotation: -finalTextAngle
+      // drawText expects CCW rotation in degrees
     });
   }
 }
 
+// lib/drawer/elements/pcb-note-dimension.ts
+var DEFAULT_NOTE_COLOR = "rgba(255,255,255,0.5)";
+function drawPcbNoteDimension(params) {
+  const { ctx, pcbNoteDimension, realToCanvasMat } = params;
+  const color = pcbNoteDimension.color ?? DEFAULT_NOTE_COLOR;
+  drawDimensionLine({
+    ctx,
+    from: pcbNoteDimension.from,
+    to: pcbNoteDimension.to,
+    realToCanvasMat,
+    color,
+    fontSize: pcbNoteDimension.font_size,
+    arrowSize: pcbNoteDimension.arrow_size,
+    text: pcbNoteDimension.text,
+    textRotation: pcbNoteDimension.text_ccw_rotation,
+    offset: pcbNoteDimension.offset_distance && pcbNoteDimension.offset_direction ? {
+      distance: pcbNoteDimension.offset_distance,
+      direction: pcbNoteDimension.offset_direction
+    } : void 0
+  });
+}
+
+// lib/drawer/elements/pcb-fabrication-note-dimension.ts
+var DEFAULT_FABRICATION_NOTE_COLOR2 = "rgba(255,255,255,0.5)";
+function drawPcbFabricationNoteDimension(params) {
+  const { ctx, pcbFabricationNoteDimension, realToCanvasMat } = params;
+  const color = pcbFabricationNoteDimension.color ?? DEFAULT_FABRICATION_NOTE_COLOR2;
+  drawDimensionLine({
+    ctx,
+    from: pcbFabricationNoteDimension.from,
+    to: pcbFabricationNoteDimension.to,
+    realToCanvasMat,
+    color,
+    fontSize: pcbFabricationNoteDimension.font_size ?? 1,
+    arrowSize: pcbFabricationNoteDimension.arrow_size ?? 1,
+    text: pcbFabricationNoteDimension.text,
+    textRotation: pcbFabricationNoteDimension.text_ccw_rotation,
+    offset: pcbFabricationNoteDimension.offset_distance && pcbFabricationNoteDimension.offset_direction ? {
+      distance: pcbFabricationNoteDimension.offset_distance,
+      direction: pcbFabricationNoteDimension.offset_direction
+    } : void 0
+  });
+}
+
 // lib/drawer/elements/pcb-note-line.ts
 import { applyToPoint as applyToPoint14 } from "transformation-matrix";
 function drawPcbNoteLine(params) {
@@ -2002,6 +2105,14 @@ var CircuitToCanvasDrawer = class {
         colorMap: this.colorMap
       });
     }
+    if (element.type === "pcb_silkscreen_oval") {
+      drawPcbSilkscreenOval({
+        ctx: this.ctx,
+        oval: element,
+        realToCanvasMat: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
     if (element.type === "pcb_cutout") {
       drawPcbCutout({
         ctx: this.ctx,
@@ -2090,6 +2201,14 @@ var CircuitToCanvasDrawer = class {
         colorMap: this.colorMap
       });
     }
+    if (element.type === "pcb_fabrication_note_dimension") {
+      drawPcbFabricationNoteDimension({
+        ctx: this.ctx,
+        pcbFabricationNoteDimension: element,
+        realToCanvasMat: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
   }
 };
 export {
@@ -2097,6 +2216,7 @@ export {
   DEFAULT_PCB_COLOR_MAP,
   drawArrow,
   drawCircle,
+  drawDimensionLine,
   drawLine,
   drawOval,
   drawPath,
@@ -2104,6 +2224,7 @@ export {
   drawPcbCopperPour,
   drawPcbCopperText,
   drawPcbCutout,
+  drawPcbFabricationNoteDimension,
   drawPcbFabricationNotePath,
   drawPcbFabricationNoteRect,
   drawPcbFabricationNoteText,
@@ -2115,6 +2236,7 @@ export {
   drawPcbPlatedHole,
   drawPcbSilkscreenCircle,
   drawPcbSilkscreenLine,
+  drawPcbSilkscreenOval,
   drawPcbSilkscreenPath,
   drawPcbSilkscreenPill,
   drawPcbSilkscreenRect,

package/lib/drawer/CircuitToCanvasDrawer.ts

@@ -10,6 +10,7 @@ import type {
   PcbSilkscreenRect,
   PcbSilkscreenCircle,
   PcbSilkscreenLine,
+  PcbSilkscreenOval,
   PcbSilkscreenPath,
   PcbSilkscreenPill,
   PcbCutout,
@@ -22,6 +23,7 @@ import type {
   PcbNotePath,
   PcbNoteText,
   PcbNoteDimension,
+  PcbFabricationNoteDimension,
   PcbNoteLine,
   PcbRenderLayer,
 } from "circuit-json"
@@ -54,6 +56,7 @@ import { drawPcbSilkscreenRect } from "./elements/pcb-silkscreen-rect"
 import { drawPcbSilkscreenCircle } from "./elements/pcb-silkscreen-circle"
 import { drawPcbSilkscreenLine } from "./elements/pcb-silkscreen-line"
 import { drawPcbSilkscreenPath } from "./elements/pcb-silkscreen-path"
+import { drawPcbSilkscreenOval } from "./elements/pcb-silkscreen-oval"
 import { drawPcbSilkscreenPill } from "./elements/pcb-silkscreen-pill"
 import { drawPcbCutout } from "./elements/pcb-cutout"
 import { drawPcbCopperPour } from "./elements/pcb-copper-pour"
@@ -65,6 +68,7 @@ import { drawPcbFabricationNotePath } from "./elements/pcb-fabrication-note-path
 import { drawPcbNotePath } from "./elements/pcb-note-path"
 import { drawPcbNoteText } from "./elements/pcb-note-text"
 import { drawPcbNoteDimension } from "./elements/pcb-note-dimension"
+import { drawPcbFabricationNoteDimension } from "./elements/pcb-fabrication-note-dimension"
 import { drawPcbNoteLine } from "./elements/pcb-note-line"
 
 export interface DrawElementsOptions {
@@ -373,6 +377,15 @@ export class CircuitToCanvasDrawer {
       })
     }
 
+    if (element.type === "pcb_silkscreen_oval") {
+      drawPcbSilkscreenOval({
+        ctx: this.ctx,
+        oval: element as PcbSilkscreenOval,
+        realToCanvasMat: this.realToCanvasMat,
+        colorMap: this.colorMap,
+      })
+    }
+
     if (element.type === "pcb_cutout") {
       drawPcbCutout({
         ctx: this.ctx,
@@ -471,5 +484,14 @@ export class CircuitToCanvasDrawer {
         colorMap: this.colorMap,
       })
     }
+
+    if (element.type === "pcb_fabrication_note_dimension") {
+      drawPcbFabricationNoteDimension({
+        ctx: this.ctx,
+        pcbFabricationNoteDimension: element as PcbFabricationNoteDimension,
+        realToCanvasMat: this.realToCanvasMat,
+        colorMap: this.colorMap,
+      })
+    }
   }
 }

package/lib/drawer/elements/index.ts

@@ -48,6 +48,11 @@ export {
   type DrawPcbSilkscreenPillParams,
 } from "./pcb-silkscreen-pill"
 
+export {
+  drawPcbSilkscreenOval,
+  type DrawPcbSilkscreenOvalParams,
+} from "./pcb-silkscreen-oval"
+
 export { drawPcbCutout, type DrawPcbCutoutParams } from "./pcb-cutout"
 
 export {
@@ -94,3 +99,8 @@ export {
   drawPcbNoteDimension,
   type DrawPcbNoteDimensionParams,
 } from "./pcb-note-dimension"
+
+export {
+  drawPcbFabricationNoteDimension,
+  type DrawPcbFabricationNoteDimensionParams,
+} from "./pcb-fabrication-note-dimension"