@tscircuit/pcb-viewer 1.0.0

package/src/components/CanvasElementsRenderer.tsx

@@ -0,0 +1,15 @@
+import { CanvasPrimitiveRenderer } from "./CanvasPrimitiveRenderer"
+import { AnyElement } from "@tscircuit/builder"
+import { useMemo } from "react"
+import { convertElementToPrimitives } from "../lib/convert-element-to-primitive"
+
+export interface CanvasElementsRendererProps {
+  elements: AnyElement[]
+}
+
+export const CanvasElementsRenderer = (props: CanvasElementsRendererProps) => {
+  const primitives = useMemo(() => {
+    return props.elements.flatMap((elm) => convertElementToPrimitives(elm))
+  }, [props.elements])
+  return <CanvasPrimitiveRenderer primitives={primitives} />
+}

package/src/components/CanvasPrimitiveRenderer.tsx

@@ -0,0 +1,25 @@
+import React, { useEffect, useRef } from "react"
+import { drawPrimitives } from "../lib/draw-primitives"
+import { Drawer } from "../lib/Drawer"
+import { Primitive } from "../lib/types"
+
+interface Props {
+  primitives: Primitive[]
+  defaultUnit?: string
+}
+
+export const CanvasPrimitiveRenderer = ({ primitives }: Props) => {
+  const ref = useRef()
+  let [width, height] = [500, 500]
+  useEffect(() => {
+    const drawer = new Drawer(ref.current)
+    drawer.clear()
+    drawPrimitives(drawer, primitives)
+  }, [primitives])
+
+  return (
+    <div style={{ backgroundColor: "black" }}>
+      <canvas ref={ref} width={width} height={height}></canvas>
+    </div>
+  )
+}

package/src/index.tsx

@@ -0,0 +1,2 @@
+export * from "./PCBViewer"
+export { CanvasElementsRenderer } from "./components/CanvasElementsRenderer"

package/src/lib/Drawer.ts

@@ -0,0 +1,168 @@
+import { scaleOnly } from "./util/scale-only"
+import {
+  identity,
+  Matrix,
+  applyToPoint,
+  translate,
+  compose,
+} from "transformation-matrix"
+import colors from "./colors"
+import { convertTextToLines } from "./convert-text-to-lines"
+
+export interface Aperture {
+  shape: "circle" | "square"
+  size: number
+  mode: "add" | "subtract"
+  fontSize: number
+  color: string
+}
+
+export const LAYER_NAME_TO_COLOR = {
+  // Standard colors, you shouldn't use these except for testing
+  red: "red",
+  black: "black",
+  green: "green",
+  // TODO more builtin html colors
+
+  // Common eagle names
+  top: colors.board.copper.f,
+  keepout: colors.board.background,
+  tkeepout: colors.board.b_crtyd,
+  tplace: colors.board.b_silks,
+
+  ...colors.board,
+}
+
+export const FILL_TYPES = {
+  0: "Empty",
+  1: "Solid",
+  2: "Line",
+  3: "LtSlash",
+  4: "Slash",
+  5: "BkSlash",
+  6: "LtBkSlash",
+  7: "Hatch",
+  8: "XHatch",
+  9: "Interleave",
+  10: "WideDot",
+  11: "CloseDot",
+  12: "Stipple1",
+  13: "Stipple2",
+  14: "Stipple3",
+  15: "Stipple4",
+}
+
+export class Drawer {
+  ctx: CanvasRenderingContext2D
+  aperture: Aperture
+  transform: Matrix
+  lastPoint: { x: number; y: number }
+
+  constructor(public canvas: HTMLCanvasElement) {
+    this.canvas = canvas
+    this.ctx = canvas.getContext("2d")
+    this.transform = identity()
+    // positive is up (cartesian)
+    this.transform.d *= -1
+    this.transform = compose(this.transform, translate(0, -500))
+  }
+
+  clear() {
+    const { ctx, canvas } = this
+    ctx.clearRect(0, 0, canvas.width, canvas.height)
+  }
+
+  equip(aperature: Partial<Aperture>) {
+    this.aperture = {
+      fontSize: 0,
+      shape: "circle",
+      mode: "add",
+      size: 0,
+      color: "red",
+      ...aperature,
+    }
+  }
+
+  rect(x: number, y: number, w: number, h: number) {
+    const [x1$, y1$] = applyToPoint(this.transform, [x, y])
+    const [x2$, y2$] = applyToPoint(this.transform, [x + w, y + h])
+    this.applyAperture()
+    this.ctx.fillRect(x1$, y1$, x2$ - x1$, y2$ - y1$)
+  }
+
+  circle(x: number, y: number, r: number) {
+    const r$ = scaleOnly(this.transform, r)
+    const [x$, y$] = applyToPoint(this.transform, [x, y])
+    this.applyAperture()
+    this.ctx.beginPath()
+    this.ctx.arc(x$, y$, r$ * 2, 0, 2 * Math.PI)
+    this.ctx.fill()
+    this.ctx.closePath()
+  }
+
+  /* NOTE: This is not gerber compatible */
+  text(text: string, x: number, y: number) {
+    const [x$, y$] = applyToPoint(this.transform, [x, y])
+    this.applyAperture()
+
+    this.ctx.fillText(text, x$, y$)
+  }
+
+  applyAperture() {
+    const { ctx, transform, aperture } = this
+    const { size, mode, color, fontSize } = aperture
+    ctx.lineWidth = scaleOnly(transform, size)
+    ctx.lineCap = "round"
+    if (mode === "add") {
+      let colorString =
+        color[0] === "#" || color.startsWith("rgb")
+          ? color
+          : LAYER_NAME_TO_COLOR[color.toLowerCase()]
+          ? LAYER_NAME_TO_COLOR[color.toLowerCase()]
+          : null
+      if (colorString === null) {
+        console.warn(`Color mapping for "${color}" not found`)
+        colorString = "white"
+      }
+      ctx.fillStyle = colorString
+      ctx.strokeStyle = colorString
+    } else {
+      ctx.globalCompositeOperation = "destination-out"
+      ctx.fillStyle = "rgba(0,0,0,1)"
+      ctx.strokeStyle = "rgba(0,0,0,1)"
+    }
+    ctx.font = `${scaleOnly(transform, fontSize)}px sans-serif`
+  }
+
+  moveTo(x: number, y: number) {
+    this.lastPoint = { x, y }
+  }
+  lineTo(x: number, y: number) {
+    const [x$, y$] = applyToPoint(this.transform, [x, y])
+    const { size, shape, mode } = this.aperture
+    const size$ = scaleOnly(this.transform, size)
+    let { lastPoint, ctx } = this
+    const lastPoint$ = applyToPoint(this.transform, lastPoint)
+
+    this.applyAperture()
+
+    if (shape === "square")
+      ctx.fillRect(
+        lastPoint$.x - size$ / 2,
+        lastPoint$.y - size$ / 2,
+        size$,
+        size$
+      )
+    ctx.beginPath()
+    ctx.moveTo(lastPoint$.x, lastPoint$.y)
+    ctx.lineTo(x$, y$)
+
+    ctx.stroke()
+    ctx.closePath()
+
+    if (shape === "square")
+      ctx.fillRect(x$ - size$ / 2, y$ - size$ / 2, size$, size$)
+
+    this.lastPoint = { x, y }
+  }
+}

package/src/lib/colors.ts

@@ -0,0 +1,233 @@
+// Mix of Eagle Dark for schematics and KiCAD 2020 for PCBs
+// https://github.com/pointhi/kicad-color-schemes/blob/master/eagle-dark/eagle-dark.jsonO
+// https://github.com/pointhi/kicad-color-schemes/blob/master/kicad-2020/kicad_2020.json
+export default {
+  "3d_viewer": {
+    background_bottom: "rgb(102, 102, 128)",
+    background_top: "rgb(204, 204, 230)",
+    board: "rgb(51, 43, 23)",
+    copper: "rgb(179, 156, 0)",
+    silkscreen_bottom: "rgb(230, 230, 230)",
+    silkscreen_top: "rgb(230, 230, 230)",
+    soldermask: "rgb(20, 51, 36)",
+    solderpaste: "rgb(128, 128, 128)",
+  },
+  board: {
+    anchor: "rgb(255, 38, 226)",
+    aux_items: "rgb(255, 255, 255)",
+    b_adhes: "rgb(0, 0, 132)",
+    b_crtyd: "rgb(255, 38, 226)",
+    b_fab: "rgb(88, 93, 132)",
+    b_mask: "rgba(2, 255, 238, 0.400)",
+    b_paste: "rgb(0, 194, 194)",
+    b_silks: "rgb(232, 178, 167)",
+    background: "rgb(0, 16, 35)",
+    cmts_user: "rgb(89, 148, 220)",
+    copper: {
+      b: "rgb(77, 127, 196)",
+      f: "rgb(200, 52, 52)",
+      in1: "rgb(127, 200, 127)",
+      in10: "rgb(237, 124, 51)",
+      in11: "rgb(91, 195, 235)",
+      in12: "rgb(247, 111, 142)",
+      in13: "rgb(167, 165, 198)",
+      in14: "rgb(40, 204, 217)",
+      in15: "rgb(232, 178, 167)",
+      in16: "rgb(242, 237, 161)",
+      in17: "rgb(237, 124, 51)",
+      in18: "rgb(91, 195, 235)",
+      in19: "rgb(247, 111, 142)",
+      in2: "rgb(206, 125, 44)",
+      in20: "rgb(167, 165, 198)",
+      in21: "rgb(40, 204, 217)",
+      in22: "rgb(232, 178, 167)",
+      in23: "rgb(242, 237, 161)",
+      in24: "rgb(237, 124, 51)",
+      in25: "rgb(91, 195, 235)",
+      in26: "rgb(247, 111, 142)",
+      in27: "rgb(167, 165, 198)",
+      in28: "rgb(40, 204, 217)",
+      in29: "rgb(232, 178, 167)",
+      in3: "rgb(79, 203, 203)",
+      in30: "rgb(242, 237, 161)",
+      in4: "rgb(219, 98, 139)",
+      in5: "rgb(167, 165, 198)",
+      in6: "rgb(40, 204, 217)",
+      in7: "rgb(232, 178, 167)",
+      in8: "rgb(242, 237, 161)",
+      in9: "rgb(141, 203, 129)",
+    },
+    cursor: "rgb(255, 255, 255)",
+    drc: "rgb(194, 194, 194)",
+    drc_error: "rgba(215, 91, 107, 0.800)",
+    drc_exclusion: "rgb(255, 255, 255)",
+    drc_warning: "rgba(255, 208, 66, 0.902)",
+    dwgs_user: "rgb(194, 194, 194)",
+    eco1_user: "rgb(180, 219, 210)",
+    eco2_user: "rgb(216, 200, 82)",
+    edge_cuts: "rgb(208, 210, 205)",
+    f_adhes: "rgb(132, 0, 132)",
+    f_crtyd: "rgb(255, 0, 245)",
+    f_fab: "rgb(175, 175, 175)",
+    f_mask: "rgba(216, 100, 255, 0.400)",
+    f_paste: "rgba(180, 160, 154, 0.902)",
+    f_silks: "rgb(242, 237, 161)",
+    footprint_text_back: "rgb(0, 0, 132)",
+    footprint_text_front: "rgb(194, 194, 194)",
+    footprint_text_invisible: "rgb(132, 132, 132)",
+    grid: "rgb(132, 132, 132)",
+    grid_axes: "rgb(194, 194, 194)",
+    margin: "rgb(255, 38, 226)",
+    microvia: "rgb(0, 132, 132)",
+    no_connect: "rgb(0, 0, 132)",
+    pad_back: "rgb(77, 127, 196)",
+    pad_front: "rgb(200, 52, 52)",
+    pad_plated_hole: "rgb(194, 194, 0)",
+    pad_through_hole: "rgb(227, 183, 46)",
+    plated_hole: "rgb(26, 196, 210)",
+    ratsnest: "rgba(245, 255, 213, 0.702)",
+    select_overlay: "rgb(4, 255, 67)",
+    through_via: "rgb(236, 236, 236)",
+    user_1: "rgb(194, 194, 194)",
+    user_2: "rgb(89, 148, 220)",
+    user_3: "rgb(180, 219, 210)",
+    user_4: "rgb(216, 200, 82)",
+    user_5: "rgb(194, 194, 194)",
+    user_6: "rgb(89, 148, 220)",
+    user_7: "rgb(180, 219, 210)",
+    user_8: "rgb(216, 200, 82)",
+    user_9: "rgb(232, 178, 167)",
+    via_blind_buried: "rgb(187, 151, 38)",
+    via_hole: "rgb(227, 183, 46)",
+    via_micro: "rgb(0, 132, 132)",
+    via_through: "rgb(236, 236, 236)",
+    worksheet: "rgb(200, 114, 171)",
+  },
+  gerbview: {
+    axes: "rgb(0, 0, 132)",
+    background: "rgb(0, 0, 0)",
+    dcodes: "rgb(255, 255, 255)",
+    grid: "rgb(132, 132, 132)",
+    layers: [
+      "rgb(132, 0, 0)",
+      "rgb(194, 194, 0)",
+      "rgb(194, 0, 194)",
+      "rgb(194, 0, 0)",
+      "rgb(0, 132, 132)",
+      "rgb(0, 132, 0)",
+      "rgb(0, 0, 132)",
+      "rgb(132, 132, 132)",
+      "rgb(132, 0, 132)",
+      "rgb(194, 194, 194)",
+      "rgb(132, 0, 132)",
+      "rgb(132, 0, 0)",
+      "rgb(132, 132, 0)",
+      "rgb(194, 194, 194)",
+      "rgb(0, 0, 132)",
+      "rgb(0, 132, 0)",
+      "rgb(132, 0, 0)",
+      "rgb(194, 194, 0)",
+      "rgb(194, 0, 194)",
+      "rgb(194, 0, 0)",
+      "rgb(0, 132, 132)",
+      "rgb(0, 132, 0)",
+      "rgb(0, 0, 132)",
+      "rgb(132, 132, 132)",
+      "rgb(132, 0, 132)",
+      "rgb(194, 194, 194)",
+      "rgb(132, 0, 132)",
+      "rgb(132, 0, 0)",
+      "rgb(132, 132, 0)",
+      "rgb(194, 194, 194)",
+      "rgb(0, 0, 132)",
+      "rgb(0, 132, 0)",
+      "rgb(132, 0, 0)",
+      "rgb(194, 194, 0)",
+      "rgb(194, 0, 194)",
+      "rgb(194, 0, 0)",
+      "rgb(0, 132, 132)",
+      "rgb(0, 132, 0)",
+      "rgb(0, 0, 132)",
+      "rgb(132, 132, 132)",
+      "rgb(132, 0, 132)",
+      "rgb(194, 194, 194)",
+      "rgb(132, 0, 132)",
+      "rgb(132, 0, 0)",
+      "rgb(132, 132, 0)",
+      "rgb(194, 194, 194)",
+      "rgb(0, 0, 132)",
+      "rgb(0, 132, 0)",
+      "rgb(132, 0, 0)",
+      "rgb(194, 194, 0)",
+      "rgb(194, 0, 194)",
+      "rgb(194, 0, 0)",
+      "rgb(0, 132, 132)",
+      "rgb(0, 132, 0)",
+      "rgb(0, 0, 132)",
+      "rgb(132, 132, 132)",
+      "rgb(132, 0, 132)",
+      "rgb(194, 194, 194)",
+      "rgb(132, 0, 132)",
+      "rgb(132, 0, 0)",
+    ],
+    negative_objects: "rgb(132, 132, 132)",
+    worksheet: "rgb(0, 0, 132)",
+  },
+  palette: [
+    "rgb(132, 0, 0)",
+    "rgb(194, 194, 0)",
+    "rgb(194, 0, 194)",
+    "rgb(194, 0, 0)",
+    "rgb(0, 132, 132)",
+    "rgb(0, 132, 0)",
+    "rgb(0, 0, 132)",
+    "rgb(132, 132, 132)",
+    "rgb(132, 0, 132)",
+    "rgb(194, 194, 194)",
+    "rgb(132, 0, 132)",
+    "rgb(132, 0, 0)",
+    "rgb(132, 132, 0)",
+    "rgb(194, 194, 194)",
+    "rgb(0, 0, 132)",
+    "rgb(0, 132, 0)",
+  ],
+  schematic: {
+    anchor: "rgb(0, 0, 255)",
+    aux_items: "rgb(0, 0, 0)",
+    background: "rgb(33, 33, 33)",
+    brightened: "rgb(204, 204, 204)",
+    bus: "rgb(0, 96, 192)",
+    bus_junction: "rgb(0, 96, 192)",
+    component_body: "rgb(44, 44, 44)",
+    component_outline: "rgb(192, 0, 0)",
+    cursor: "rgb(224, 224, 224)",
+    erc_error: "rgba(192, 48, 48, 0.800)",
+    erc_warning: "rgba(192, 140, 0, 0.800)",
+    fields: "rgb(128, 0, 160)",
+    grid: "rgb(60, 60, 60)",
+    grid_axes: "rgb(60, 60, 60)",
+    hidden: "rgb(194, 194, 194)",
+    junction: "rgb(0, 160, 0)",
+    label_global: "rgb(0, 160, 224)",
+    label_hier: "rgb(160, 160, 0)",
+    label_local: "rgb(192, 192, 192)",
+    net_name: "rgb(224, 224, 224)",
+    no_connect: "rgb(97, 43, 224)",
+    note: "rgb(192, 192, 0)",
+    override_item_colors: false,
+    pin: "rgb(192, 0, 0)",
+    pin_name: "rgb(192, 192, 192)",
+    pin_number: "rgb(192, 0, 0)",
+    reference: "rgb(192, 192, 192)",
+    shadow: "rgba(102, 179, 255, 0.800)",
+    sheet: "rgb(128, 0, 160)",
+    sheet_background: "rgba(255, 255, 255, 0.000)",
+    sheet_fields: "rgb(160, 160, 0)",
+    sheet_filename: "rgb(160, 160, 0)",
+    sheet_label: "rgb(160, 160, 0)",
+    sheet_name: "rgb(0, 160, 204)",
+    value: "rgb(192, 192, 192)",
+    wire: "rgb(0, 160, 0)",
+    worksheet: "rgb(192, 0, 0)",
+  },
+}

package/src/lib/convert-element-to-primitive.ts

@@ -0,0 +1,31 @@
+import { AnyElement } from "@tscircuit/builder"
+import { Primitive } from "./types"
+
+export const convertElementToPrimitives = (
+  element: AnyElement
+): Primitive[] => {
+  switch (element.type) {
+    case "pcb_smtpad": {
+      if (element.shape === "rect") {
+        const { shape, x, y, width, height, layer } = element
+
+        return [
+          {
+            pcb_drawing_type: "rect",
+            x,
+            y,
+            w: width,
+            h: height,
+            layer: layer,
+          },
+        ]
+      } else if (element.shape === "circle") {
+        console.warn(`Unsupported shape: ${element.shape} for pcb_smtpad`)
+        return []
+      }
+    }
+  }
+
+  console.warn(`Unsupported element type: ${element.type}`)
+  return []
+}

package/src/lib/convert-text-to-lines.ts

@@ -0,0 +1,31 @@
+import { lineAlphabet } from "../assets/alphabet"
+import { Line, Text } from "./types"
+
+export const convertTextToLines = (text: Text): Line[] => {
+  const strokeWidth = text.size / 8
+  const letterWidth = text.size * 0.6
+  const letterSpace = text.size * 0.2
+
+  const lines: Line[] = []
+  for (let letterIndex = 0; letterIndex < text.text.length; letterIndex++) {
+    const letter = text.text[letterIndex]
+    const letterLines = lineAlphabet[letter.toUpperCase()]
+    if (!letterLines) continue
+    for (const { x1, y1, x2, y2 } of letterLines) {
+      lines.push({
+        pcb_drawing_type: "line",
+        x1:
+          text.x + (letterWidth + letterSpace) * letterIndex + letterWidth * x1,
+        y1: text.y + text.size * y1,
+        x2:
+          text.x + (letterWidth + letterSpace) * letterIndex + letterWidth * x2,
+        y2: text.y + text.size * y2,
+        width: strokeWidth,
+        layer: text.layer,
+        unit: text.unit,
+      })
+    }
+  }
+
+  return lines
+}

package/src/lib/draw-eagle.ts

@@ -0,0 +1,45 @@
+import { EagleJSON, Layer } from "@tscircuit/eagle-xml-converter"
+import {
+  compose,
+  fromDefinition,
+  fromTransformAttribute,
+} from "transformation-matrix"
+import { Drawer } from "./Drawer"
+
+export const drawEagle = (drawer: Drawer, eagle: EagleJSON) => {
+  const pkg = eagle.library.packages[0]
+
+  if (eagle.grid.unit === "inch") {
+    drawer.transform = compose(
+      fromDefinition(
+        fromTransformAttribute("translate(200, 200) scale(30,-30)")
+      )
+    )
+  }
+
+  const layerMap: Record<number, Layer> = {}
+  for (const layer of eagle.layers) {
+    layerMap[layer.number] = layer
+  }
+
+  for (const smd of pkg.smd || []) {
+    drawer.equip({
+      color: layerMap[smd.layer].name,
+    })
+    drawer.rect(smd.x - smd.dx / 2, smd.y - smd.dy / 2, smd.dx, smd.dy)
+  }
+  for (const wire of pkg.wire || []) {
+    drawer.equip({
+      size: wire.width,
+      shape: "circle",
+      color: layerMap[wire.layer].name,
+    })
+    drawer.moveTo(wire.x1, wire.y1)
+    drawer.lineTo(wire.x2, wire.y2)
+  }
+
+  for (const circle of pkg.circle || []) {
+    drawer.equip({ color: layerMap[circle.layer].name })
+    drawer.circle(circle.x, circle.y, circle.radius)
+  }
+}

package/src/lib/draw-primitives.ts

@@ -0,0 +1,69 @@
+import { Primitive, Line, Text, Circle, Rect } from "./types"
+import { Drawer } from "./Drawer"
+import { convertTextToLines } from "./convert-text-to-lines"
+
+export const drawLine = (drawer: Drawer, line: Line) => {
+  drawer.equip({
+    size: line.width,
+    shape: line.squareCap ? "square" : "circle",
+    color: line.layer.name,
+  })
+  drawer.moveTo(line.x1, line.y1)
+  drawer.lineTo(line.x2, line.y2)
+}
+
+export const drawText = (drawer: Drawer, text: Text) => {
+  drawer.equip({
+    fontSize: text.size,
+    color: text.layer.name,
+  })
+  // TODO handle align
+  if (text.align && text.align !== "top-left") {
+    console.warn("Unhandled text align", text.align)
+  }
+
+  // Non-gerber compatible
+  // drawer.text(text.text, text.x, text.y)
+
+  const lines = convertTextToLines(text)
+  for (const line of lines) {
+    drawLine(drawer, line)
+  }
+}
+
+export const drawRect = (drawer: Drawer, rect: Rect) => {
+  drawer.equip({
+    color: rect.layer.name,
+  })
+  if (rect.align && rect.align !== "center") {
+    console.warn("Unhandled rect align", rect.align)
+  }
+  drawer.rect(rect.x, rect.y, rect.w, rect.h)
+}
+
+export const drawCircle = (drawer: Drawer, circle: Circle) => {
+  drawer.equip({
+    color: circle.layer.name,
+  })
+  drawer.circle(circle.x, circle.y, circle.r)
+}
+
+export const drawPrimitive = (drawer: Drawer, primitive: Primitive) => {
+  switch (primitive.pcb_drawing_type) {
+    case "line":
+      return drawLine(drawer, primitive)
+    case "text":
+      return drawText(drawer, primitive)
+    case "rect":
+      return drawRect(drawer, primitive)
+    case "circle":
+      return drawCircle(drawer, primitive)
+  }
+  throw new Error(
+    `Unknown primitive type: ${(primitive as any).pcb_drawing_type}`
+  )
+}
+
+export const drawPrimitives = (drawer: Drawer, primitives: Primitive[]) => {
+  primitives.forEach((primitive) => drawPrimitive(drawer, primitive))
+}

package/src/lib/types.ts

@@ -0,0 +1,54 @@
+export type AlignString =
+  | "top-left"
+  | "top-center"
+  | "top-right"
+  | "center-left"
+  | "center"
+  | "center-right"
+  | "bottom-left"
+  | "bottom-center"
+  | "bottom-right"
+
+export interface LayerRef {
+  name: string
+}
+
+export interface PCBDrawingObject {
+  layer: LayerRef
+  unit?: string
+}
+
+export interface Line extends PCBDrawingObject {
+  pcb_drawing_type: "line"
+  x1: number
+  y1: number
+  x2: number
+  y2: number
+  squareCap?: boolean
+  width: number
+}
+export interface Text extends PCBDrawingObject {
+  pcb_drawing_type: "text"
+  text: string
+  x: number
+  y: number
+  size: number
+  align?: AlignString
+}
+export interface Rect extends PCBDrawingObject {
+  pcb_drawing_type: "rect"
+  x: number
+  y: number
+  w: number
+  h: number
+  roundness?: number
+  align?: AlignString
+}
+export interface Circle extends PCBDrawingObject {
+  pcb_drawing_type: "circle"
+  x: number
+  y: number
+  r: number
+}
+
+export type Primitive = Line | Text | Rect | Circle

package/src/lib/util/scale-only.ts

@@ -0,0 +1,7 @@
+import { Matrix } from "transformation-matrix"
+
+export const scaleOnly = (mat: Matrix, value: number) => {
+  if (Math.abs(mat.a) !== Math.abs(mat.d))
+    throw new Error("Cannot scale non-uniformly")
+  return value * Math.abs(mat.a)
+}