circuit-to-canvas 0.0.1 → 0.0.2

package/dist/index.js

@@ -285,6 +285,515 @@ function drawPcbPlatedHole(params) {
   }
 }
 
+// lib/drawer/elements/pcb-via.ts
+function drawPcbVia(params) {
+  const { ctx, via, transform, colorMap } = params;
+  drawCircle({
+    ctx,
+    center: { x: via.x, y: via.y },
+    radius: via.outer_diameter / 2,
+    fill: colorMap.copper.top,
+    transform
+  });
+  drawCircle({
+    ctx,
+    center: { x: via.x, y: via.y },
+    radius: via.hole_diameter / 2,
+    fill: colorMap.drill,
+    transform
+  });
+}
+
+// lib/drawer/elements/pcb-hole.ts
+function drawPcbHole(params) {
+  const { ctx, hole, transform, colorMap } = params;
+  if (hole.hole_shape === "circle") {
+    drawCircle({
+      ctx,
+      center: { x: hole.x, y: hole.y },
+      radius: hole.hole_diameter / 2,
+      fill: colorMap.drill,
+      transform
+    });
+    return;
+  }
+  if (hole.hole_shape === "square") {
+    drawRect({
+      ctx,
+      center: { x: hole.x, y: hole.y },
+      width: hole.hole_diameter,
+      height: hole.hole_diameter,
+      fill: colorMap.drill,
+      transform
+    });
+    return;
+  }
+  if (hole.hole_shape === "oval") {
+    drawOval({
+      ctx,
+      center: { x: hole.x, y: hole.y },
+      width: hole.hole_width,
+      height: hole.hole_height,
+      fill: colorMap.drill,
+      transform
+    });
+    return;
+  }
+  if (hole.hole_shape === "rect") {
+    drawRect({
+      ctx,
+      center: { x: hole.x, y: hole.y },
+      width: hole.hole_width,
+      height: hole.hole_height,
+      fill: colorMap.drill,
+      transform
+    });
+    return;
+  }
+  if (hole.hole_shape === "pill") {
+    drawPill({
+      ctx,
+      center: { x: hole.x, y: hole.y },
+      width: hole.hole_width,
+      height: hole.hole_height,
+      fill: colorMap.drill,
+      transform
+    });
+    return;
+  }
+  if (hole.hole_shape === "rotated_pill") {
+    drawPill({
+      ctx,
+      center: { x: hole.x, y: hole.y },
+      width: hole.hole_width,
+      height: hole.hole_height,
+      fill: colorMap.drill,
+      transform,
+      rotation: hole.ccw_rotation ?? 0
+    });
+    return;
+  }
+}
+
+// lib/drawer/shapes/polygon.ts
+import { applyToPoint as applyToPoint5 } from "transformation-matrix";
+function drawPolygon(params) {
+  const { ctx, points, fill, transform } = params;
+  if (points.length < 3) return;
+  ctx.beginPath();
+  const transformedPoints = points.map(
+    (p) => applyToPoint5(transform, [p.x, p.y])
+  );
+  const firstPoint = transformedPoints[0];
+  if (!firstPoint) return;
+  const [firstX, firstY] = firstPoint;
+  ctx.moveTo(firstX, firstY);
+  for (let i = 1; i < transformedPoints.length; i++) {
+    const point = transformedPoints[i];
+    if (!point) continue;
+    const [x, y] = point;
+    ctx.lineTo(x, y);
+  }
+  ctx.closePath();
+  ctx.fillStyle = fill;
+  ctx.fill();
+}
+
+// lib/drawer/elements/pcb-smtpad.ts
+function layerToColor(layer, colorMap) {
+  return colorMap.copper[layer] ?? colorMap.copper.top;
+}
+function drawPcbSmtPad(params) {
+  const { ctx, pad, transform, colorMap } = params;
+  const color = layerToColor(pad.layer, colorMap);
+  if (pad.shape === "rect") {
+    drawRect({
+      ctx,
+      center: { x: pad.x, y: pad.y },
+      width: pad.width,
+      height: pad.height,
+      fill: color,
+      transform,
+      borderRadius: pad.corner_radius ?? pad.rect_border_radius ?? 0
+    });
+    return;
+  }
+  if (pad.shape === "rotated_rect") {
+    drawRect({
+      ctx,
+      center: { x: pad.x, y: pad.y },
+      width: pad.width,
+      height: pad.height,
+      fill: color,
+      transform,
+      borderRadius: pad.corner_radius ?? pad.rect_border_radius ?? 0,
+      rotation: pad.ccw_rotation ?? 0
+    });
+    return;
+  }
+  if (pad.shape === "circle") {
+    drawCircle({
+      ctx,
+      center: { x: pad.x, y: pad.y },
+      radius: pad.radius,
+      fill: color,
+      transform
+    });
+    return;
+  }
+  if (pad.shape === "pill") {
+    drawPill({
+      ctx,
+      center: { x: pad.x, y: pad.y },
+      width: pad.width,
+      height: pad.height,
+      fill: color,
+      transform
+    });
+    return;
+  }
+  if (pad.shape === "rotated_pill") {
+    drawPill({
+      ctx,
+      center: { x: pad.x, y: pad.y },
+      width: pad.width,
+      height: pad.height,
+      fill: color,
+      transform,
+      rotation: pad.ccw_rotation ?? 0
+    });
+    return;
+  }
+  if (pad.shape === "polygon") {
+    if (pad.points && pad.points.length >= 3) {
+      drawPolygon({
+        ctx,
+        points: pad.points,
+        fill: color,
+        transform
+      });
+    }
+    return;
+  }
+}
+
+// lib/drawer/shapes/line.ts
+import { applyToPoint as applyToPoint6 } from "transformation-matrix";
+function drawLine(params) {
+  const {
+    ctx,
+    start,
+    end,
+    strokeWidth,
+    stroke,
+    transform,
+    lineCap = "round"
+  } = params;
+  const [x1, y1] = applyToPoint6(transform, [start.x, start.y]);
+  const [x2, y2] = applyToPoint6(transform, [end.x, end.y]);
+  const scaledStrokeWidth = strokeWidth * Math.abs(transform.a);
+  ctx.beginPath();
+  ctx.moveTo(x1, y1);
+  ctx.lineTo(x2, y2);
+  ctx.lineWidth = scaledStrokeWidth;
+  ctx.strokeStyle = stroke;
+  ctx.lineCap = lineCap;
+  ctx.stroke();
+}
+
+// lib/drawer/elements/pcb-trace.ts
+function layerToColor2(layer, colorMap) {
+  return colorMap.copper[layer] ?? colorMap.copper.top;
+}
+function drawPcbTrace(params) {
+  const { ctx, trace, transform, colorMap } = params;
+  if (!trace.route || !Array.isArray(trace.route) || trace.route.length < 2) {
+    return;
+  }
+  for (let i = 0; i < trace.route.length - 1; i++) {
+    const start = trace.route[i];
+    const end = trace.route[i + 1];
+    if (!start || !end) continue;
+    const layer = "layer" in start ? start.layer : "layer" in end ? end.layer : null;
+    if (!layer) continue;
+    const color = layerToColor2(layer, colorMap);
+    const traceWidth = "width" in start ? start.width : "width" in end ? end.width : 0.1;
+    drawLine({
+      ctx,
+      start: { x: start.x, y: start.y },
+      end: { x: end.x, y: end.y },
+      strokeWidth: traceWidth,
+      stroke: color,
+      transform,
+      lineCap: "round"
+    });
+  }
+}
+
+// lib/drawer/shapes/path.ts
+import { applyToPoint as applyToPoint7 } from "transformation-matrix";
+function drawPath(params) {
+  const {
+    ctx,
+    points,
+    fill,
+    stroke,
+    strokeWidth = 1,
+    transform,
+    closePath = false
+  } = params;
+  if (points.length < 2) return;
+  ctx.beginPath();
+  const transformedPoints = points.map(
+    (p) => applyToPoint7(transform, [p.x, p.y])
+  );
+  const firstPoint = transformedPoints[0];
+  if (!firstPoint) return;
+  const [firstX, firstY] = firstPoint;
+  ctx.moveTo(firstX, firstY);
+  for (let i = 1; i < transformedPoints.length; i++) {
+    const point = transformedPoints[i];
+    if (!point) continue;
+    const [x, y] = point;
+    ctx.lineTo(x, y);
+  }
+  if (closePath) {
+    ctx.closePath();
+  }
+  if (fill) {
+    ctx.fillStyle = fill;
+    ctx.fill();
+  }
+  if (stroke) {
+    const scaledStrokeWidth = strokeWidth * Math.abs(transform.a);
+    ctx.strokeStyle = stroke;
+    ctx.lineWidth = scaledStrokeWidth;
+    ctx.stroke();
+  }
+}
+
+// lib/drawer/elements/pcb-board.ts
+function drawPcbBoard(params) {
+  const { ctx, board, transform, colorMap } = params;
+  const { width, height, center, outline } = board;
+  if (outline && Array.isArray(outline) && outline.length >= 3) {
+    drawPath({
+      ctx,
+      points: outline.map((p) => ({ x: p.x, y: p.y })),
+      stroke: colorMap.boardOutline,
+      strokeWidth: 0.1,
+      transform,
+      closePath: true
+    });
+    return;
+  }
+  if (width !== void 0 && height !== void 0 && center) {
+    drawRect({
+      ctx,
+      center,
+      width,
+      height,
+      fill: "transparent",
+      transform
+    });
+    const halfWidth = width / 2;
+    const halfHeight = height / 2;
+    const corners = [
+      { x: center.x - halfWidth, y: center.y - halfHeight },
+      { x: center.x + halfWidth, y: center.y - halfHeight },
+      { x: center.x + halfWidth, y: center.y + halfHeight },
+      { x: center.x - halfWidth, y: center.y + halfHeight }
+    ];
+    drawPath({
+      ctx,
+      points: corners,
+      stroke: colorMap.boardOutline,
+      strokeWidth: 0.1,
+      transform,
+      closePath: true
+    });
+  }
+}
+
+// lib/drawer/elements/pcb-silkscreen.ts
+import { applyToPoint as applyToPoint8 } from "transformation-matrix";
+function layerToSilkscreenColor(layer, colorMap) {
+  return layer === "bottom" ? colorMap.silkscreen.bottom : colorMap.silkscreen.top;
+}
+function mapAnchorAlignment(alignment) {
+  if (!alignment) return "center";
+  if (alignment.includes("left")) return "left";
+  if (alignment.includes("right")) return "right";
+  return "center";
+}
+function drawPcbSilkscreenText(params) {
+  const { ctx, text, transform, colorMap } = params;
+  const color = layerToSilkscreenColor(text.layer, colorMap);
+  const [x, y] = applyToPoint8(transform, [
+    text.anchor_position.x,
+    text.anchor_position.y
+  ]);
+  const fontSize = (text.font_size ?? 1) * Math.abs(transform.a);
+  const rotation = text.ccw_rotation ?? 0;
+  ctx.save();
+  ctx.translate(x, y);
+  if (rotation !== 0) {
+    ctx.rotate(-rotation * (Math.PI / 180));
+  }
+  ctx.font = `${fontSize}px sans-serif`;
+  ctx.fillStyle = color;
+  ctx.textAlign = mapAnchorAlignment(text.anchor_alignment);
+  ctx.textBaseline = "middle";
+  ctx.fillText(text.text, 0, 0);
+  ctx.restore();
+}
+function drawPcbSilkscreenRect(params) {
+  const { ctx, rect, transform, colorMap } = params;
+  const color = layerToSilkscreenColor(rect.layer, colorMap);
+  drawRect({
+    ctx,
+    center: rect.center,
+    width: rect.width,
+    height: rect.height,
+    fill: color,
+    transform
+  });
+}
+function drawPcbSilkscreenCircle(params) {
+  const { ctx, circle, transform, colorMap } = params;
+  const color = layerToSilkscreenColor(circle.layer, colorMap);
+  drawCircle({
+    ctx,
+    center: circle.center,
+    radius: circle.radius,
+    fill: color,
+    transform
+  });
+}
+function drawPcbSilkscreenLine(params) {
+  const { ctx, line, transform, colorMap } = params;
+  const color = layerToSilkscreenColor(line.layer, colorMap);
+  drawLine({
+    ctx,
+    start: { x: line.x1, y: line.y1 },
+    end: { x: line.x2, y: line.y2 },
+    strokeWidth: line.stroke_width ?? 0.1,
+    stroke: color,
+    transform
+  });
+}
+function drawPcbSilkscreenPath(params) {
+  const { ctx, path, transform, colorMap } = params;
+  const color = layerToSilkscreenColor(path.layer, colorMap);
+  if (!path.route || path.route.length < 2) return;
+  for (let i = 0; i < path.route.length - 1; i++) {
+    const start = path.route[i];
+    const end = path.route[i + 1];
+    if (!start || !end) continue;
+    drawLine({
+      ctx,
+      start: { x: start.x, y: start.y },
+      end: { x: end.x, y: end.y },
+      strokeWidth: path.stroke_width ?? 0.1,
+      stroke: color,
+      transform
+    });
+  }
+}
+
+// lib/drawer/elements/pcb-cutout.ts
+function drawPcbCutout(params) {
+  const { ctx, cutout, transform, colorMap } = params;
+  if (cutout.shape === "rect") {
+    drawRect({
+      ctx,
+      center: cutout.center,
+      width: cutout.width,
+      height: cutout.height,
+      fill: colorMap.drill,
+      transform,
+      rotation: cutout.rotation ?? 0
+    });
+    return;
+  }
+  if (cutout.shape === "circle") {
+    drawCircle({
+      ctx,
+      center: cutout.center,
+      radius: cutout.radius,
+      fill: colorMap.drill,
+      transform
+    });
+    return;
+  }
+  if (cutout.shape === "polygon") {
+    if (cutout.points && cutout.points.length >= 3) {
+      drawPolygon({
+        ctx,
+        points: cutout.points,
+        fill: colorMap.drill,
+        transform
+      });
+    }
+    return;
+  }
+}
+
+// lib/drawer/elements/pcb-copper-pour.ts
+import { applyToPoint as applyToPoint9 } from "transformation-matrix";
+function layerToColor3(layer, colorMap) {
+  return colorMap.copper[layer] ?? colorMap.copper.top;
+}
+function drawPcbCopperPour(params) {
+  const { ctx, pour, transform, colorMap } = params;
+  const color = layerToColor3(pour.layer, colorMap);
+  ctx.save();
+  if (pour.shape === "rect") {
+    const [cx, cy] = applyToPoint9(transform, [pour.center.x, pour.center.y]);
+    const scaledWidth = pour.width * Math.abs(transform.a);
+    const scaledHeight = pour.height * Math.abs(transform.a);
+    ctx.translate(cx, cy);
+    if (pour.rotation) {
+      ctx.rotate(-pour.rotation * (Math.PI / 180));
+    }
+    ctx.beginPath();
+    ctx.rect(-scaledWidth / 2, -scaledHeight / 2, scaledWidth, scaledHeight);
+    ctx.fillStyle = color;
+    ctx.globalAlpha = 0.5;
+    ctx.fill();
+    ctx.restore();
+    return;
+  }
+  if (pour.shape === "polygon") {
+    if (pour.points && pour.points.length >= 3) {
+      const transformedPoints = pour.points.map(
+        (p) => applyToPoint9(transform, [p.x, p.y])
+      );
+      const firstPoint = transformedPoints[0];
+      if (!firstPoint) {
+        ctx.restore();
+        return;
+      }
+      ctx.beginPath();
+      const [firstX, firstY] = firstPoint;
+      ctx.moveTo(firstX, firstY);
+      for (let i = 1; i < transformedPoints.length; i++) {
+        const point = transformedPoints[i];
+        if (!point) continue;
+        const [x, y] = point;
+        ctx.lineTo(x, y);
+      }
+      ctx.closePath();
+      ctx.fillStyle = color;
+      ctx.globalAlpha = 0.5;
+      ctx.fill();
+    }
+    ctx.restore();
+    return;
+  }
+  ctx.restore();
+}
+
 // lib/drawer/CircuitToCanvasDrawer.ts
 var CircuitToCanvasDrawer = class {
   ctx;
@@ -362,14 +871,125 @@ var CircuitToCanvasDrawer = class {
         colorMap: this.colorMap
       });
     }
+    if (element.type === "pcb_via") {
+      drawPcbVia({
+        ctx: this.ctx,
+        via: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_hole") {
+      drawPcbHole({
+        ctx: this.ctx,
+        hole: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_smtpad") {
+      drawPcbSmtPad({
+        ctx: this.ctx,
+        pad: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_trace") {
+      drawPcbTrace({
+        ctx: this.ctx,
+        trace: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_board") {
+      drawPcbBoard({
+        ctx: this.ctx,
+        board: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_silkscreen_text") {
+      drawPcbSilkscreenText({
+        ctx: this.ctx,
+        text: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_silkscreen_rect") {
+      drawPcbSilkscreenRect({
+        ctx: this.ctx,
+        rect: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_silkscreen_circle") {
+      drawPcbSilkscreenCircle({
+        ctx: this.ctx,
+        circle: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_silkscreen_line") {
+      drawPcbSilkscreenLine({
+        ctx: this.ctx,
+        line: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_silkscreen_path") {
+      drawPcbSilkscreenPath({
+        ctx: this.ctx,
+        path: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_cutout") {
+      drawPcbCutout({
+        ctx: this.ctx,
+        cutout: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
+    if (element.type === "pcb_copper_pour") {
+      drawPcbCopperPour({
+        ctx: this.ctx,
+        pour: element,
+        transform: this.realToCanvasMat,
+        colorMap: this.colorMap
+      });
+    }
   }
 };
 export {
   CircuitToCanvasDrawer,
   DEFAULT_PCB_COLOR_MAP,
   drawCircle,
+  drawLine,
   drawOval,
+  drawPath,
+  drawPcbBoard,
+  drawPcbCopperPour,
+  drawPcbCutout,
+  drawPcbHole,
   drawPcbPlatedHole,
+  drawPcbSilkscreenCircle,
+  drawPcbSilkscreenLine,
+  drawPcbSilkscreenPath,
+  drawPcbSilkscreenRect,
+  drawPcbSilkscreenText,
+  drawPcbSmtPad,
+  drawPcbTrace,
+  drawPcbVia,
   drawPill,
+  drawPolygon,
   drawRect
 };