kicadts 0.0.1

package/tests/sexpr/classes/FootprintPad.test.ts

@@ -0,0 +1,71 @@
+import { FootprintPad, PadLayers, PadNet, PadSize, PadDrill, SxClass } from "lib/sexpr"
+import { expect, test } from "bun:test"
+
+test("FootprintPad", () => {
+  const [pad] = SxClass.parse(`
+    (pad "1" smd roundrect
+      (at 1.5 -2.5 180)
+      (size 1.2 0.6)
+      (drill 0.3)
+      (layers F.Cu F.Paste F.Mask)
+      (roundrect_rratio 0.25)
+      (chamfer top_left bottom_right)
+      (solder_mask_margin 0.05)
+      (solder_paste_margin_ratio -0.1)
+      (clearance 0.15)
+      (zone_connect 1)
+      (thermal_gap 0.2)
+      (thermal_width 0.12)
+      (net 3 "SIG")
+      (pinfunction "SIG")
+      (pintype "input")
+      (uuid 55555555-6666-7777-8888-999999999999)
+      locked
+    )
+  `)
+
+  expect(pad).toBeInstanceOf(FootprintPad)
+  const fpPad = pad as FootprintPad
+  expect(fpPad.number).toBe("1")
+  expect(fpPad.padType).toBe("smd")
+  expect(fpPad.shape).toBe("roundrect")
+  expect(fpPad.at).toBeDefined()
+  expect(fpPad.size).toBeInstanceOf(PadSize)
+  expect(fpPad.size?.width).toBe(1.2)
+  expect(fpPad.size?.height).toBe(0.6)
+  expect(fpPad.drill).toBeInstanceOf(PadDrill)
+  expect(fpPad.drill?.oval).toBe(false)
+  expect(fpPad.drill?.diameter).toBe(0.3)
+  expect(fpPad.layers).toBeInstanceOf(PadLayers)
+  expect(fpPad.layers?.layers).toEqual(["F.Cu", "F.Paste", "F.Mask"])
+  expect(fpPad.roundrectRatio).toBe(0.25)
+  expect(fpPad.chamferCorners).toEqual(["top_left", "bottom_right"])
+  expect(fpPad.net).toBeInstanceOf(PadNet)
+  expect(fpPad.net?.id).toBe(3)
+  expect(fpPad.net?.name).toBe("SIG")
+  expect(fpPad.pinfunction).toBe("SIG")
+  expect(fpPad.pintype).toBe("input")
+  expect(fpPad.locked).toBe(true)
+
+  expect(fpPad.getString()).toMatchInlineSnapshot(`
+    "(pad \"1\" smd roundrect
+      (at 1.5 -2.5 180)
+      (size 1.2 0.6)
+      (drill 0.3)
+      (layers F.Cu F.Paste F.Mask)
+      (roundrect_rratio 0.25)
+      (chamfer top_left bottom_right)
+      (net 3 \"SIG\")
+      (pinfunction SIG)
+      (pintype input)
+      (solder_mask_margin 0.05)
+      (solder_paste_margin_ratio -0.1)
+      (clearance 0.15)
+      (zone_connect 1)
+      (thermal_width 0.12)
+      (thermal_gap 0.2)
+      (uuid 55555555-6666-7777-8888-999999999999)
+      locked
+    )"
+  `)
+})

package/tests/sexpr/classes/FpArc.test.ts

@@ -0,0 +1,45 @@
+import { FpArc, Layer, Stroke, SxClass } from "lib/sexpr"
+import { expect, test } from "bun:test"
+
+test("FpArc", () => {
+  const [arc] = SxClass.parse(`
+    (fp_arc
+      (start 0 0)
+      (mid 1 1)
+      (end 2 0)
+      (layer F.SilkS)
+      (stroke (width 0.12) (type solid) (color 0 0 1 1))
+      (uuid 12340000-0000-0000-0000-000000000000)
+    )
+  `)
+
+  expect(arc).toBeInstanceOf(FpArc)
+  const fpArc = arc as FpArc
+  expect(fpArc.start?.x).toBe(0)
+  expect(fpArc.mid?.y).toBe(1)
+  expect(fpArc.end?.x).toBe(2)
+  expect(fpArc.layer).toBeInstanceOf(Layer)
+  expect(fpArc.stroke).toBeInstanceOf(Stroke)
+  expect(fpArc.uuid).toBe("12340000-0000-0000-0000-000000000000")
+
+  fpArc.width = 0.25
+  expect(fpArc.width).toBe(0.25)
+  fpArc.locked = true
+
+  expect(fpArc.getString()).toMatchInlineSnapshot(`
+    "(fp_arc
+      (start 0 0)
+      (mid 1 1)
+      (end 2 0)
+      (layer F.SilkS)
+      (width 0.25)
+      (stroke
+        (width 0.12)
+        (type solid)
+        (color 0 0 1 1)
+      )
+      (uuid 12340000-0000-0000-0000-000000000000)
+      locked
+    )"
+  `)
+})

package/tests/sexpr/classes/FpCircle.test.ts

@@ -0,0 +1,39 @@
+import { FpCircle, Layer, Stroke, SxClass } from "lib/sexpr"
+import { expect, test } from "bun:test"
+
+test("FpCircle", () => {
+  const [circle] = SxClass.parse(`
+    (fp_circle
+      (center 1 1)
+      (end 2 1)
+      (layer F.SilkS)
+      (stroke (width 0.1) (type dash) (color 0.2 0.2 0.2 1))
+      (uuid 55555555-6666-7777-8888-999999999999)
+    )
+  `)
+
+  expect(circle).toBeInstanceOf(FpCircle)
+  const fpCircle = circle as FpCircle
+  expect(fpCircle.center?.x).toBe(1)
+  expect(fpCircle.end?.x).toBe(2)
+  expect(fpCircle.layer).toBeInstanceOf(Layer)
+  expect(fpCircle.stroke).toBeInstanceOf(Stroke)
+  expect(fpCircle.uuid).toBe("55555555-6666-7777-8888-999999999999")
+
+  fpCircle.locked = true
+
+  expect(fpCircle.getString()).toMatchInlineSnapshot(`
+    "(fp_circle
+      (center 1 1)
+      (end 2 1)
+      (layer F.SilkS)
+      (stroke
+        (width 0.1)
+        (type dash)
+        (color 0.2 0.2 0.2 1)
+      )
+      (uuid 55555555-6666-7777-8888-999999999999)
+      locked
+    )"
+  `)
+})

package/tests/sexpr/classes/FpPoly.test.ts

@@ -0,0 +1,43 @@
+import { FpPoly, Layer, Pts, Stroke, SxClass } from "lib/sexpr"
+import { expect, test } from "bun:test"
+
+test("FpPoly", () => {
+  const [poly] = SxClass.parse(`
+    (fp_poly
+      (pts (xy 0 0) (xy 1 0) (xy 1 1) (xy 0 1))
+      (layer F.SilkS)
+      (stroke (width 0.1) (type solid) (color 0 0 0 1))
+      (fill yes)
+      (uuid 10101010-2020-3030-4040-505050505050)
+    )
+  `)
+
+  expect(poly).toBeInstanceOf(FpPoly)
+  const fpPoly = poly as FpPoly
+  expect(fpPoly.points).toBeInstanceOf(Pts)
+  expect(fpPoly.layer).toBeInstanceOf(Layer)
+  expect(fpPoly.stroke).toBeInstanceOf(Stroke)
+  expect(fpPoly.fill?.filled).toBe(true)
+
+  fpPoly.locked = true
+
+  expect(fpPoly.getString()).toMatchInlineSnapshot(`
+    "(fp_poly
+      (pts
+        (xy 0 0)
+        (xy 1 0)
+        (xy 1 1)
+        (xy 0 1)
+      )
+      (layer F.SilkS)
+      (stroke
+        (width 0.1)
+        (type solid)
+        (color 0 0 0 1)
+      )
+      (fill yes)
+      (locked yes)
+      (uuid 10101010-2020-3030-4040-505050505050)
+    )"
+  `)
+})

package/tests/sexpr/classes/FpRect.test.ts

@@ -0,0 +1,40 @@
+import { FpRect, Layer, Stroke, SxClass } from "lib/sexpr"
+import { expect, test } from "bun:test"
+
+test("FpRect", () => {
+  const [rect] = SxClass.parse(`
+    (fp_rect
+      (start 0 0)
+      (end 5 5)
+      (layer F.Cu)
+      (stroke (width 0.2) (type solid) (color 1 0 0 1))
+      (uuid 00000000-1111-2222-3333-444444444444)
+    )
+  `)
+
+  expect(rect).toBeInstanceOf(FpRect)
+  const fpRect = rect as FpRect
+  expect(fpRect.start?.x).toBe(0)
+  expect(fpRect.end?.y).toBe(5)
+  expect(fpRect.layer).toBeInstanceOf(Layer)
+  expect(fpRect.stroke).toBeInstanceOf(Stroke)
+  expect(fpRect.uuid).toBe("00000000-1111-2222-3333-444444444444")
+
+  fpRect.width = 0.3
+  expect(fpRect.width).toBe(0.3)
+
+  expect(fpRect.getString()).toMatchInlineSnapshot(`
+    "(fp_rect
+      (start 0 0)
+      (end 5 5)
+      (layer F.Cu)
+      (width 0.3)
+      (stroke
+        (width 0.2)
+        (type solid)
+        (color 1 0 0 1)
+      )
+      (uuid 00000000-1111-2222-3333-444444444444)
+    )"
+  `)
+})

package/tests/sexpr/classes/FpTextBox.test.ts

@@ -0,0 +1,84 @@
+import {
+  FpTextBox,
+  FpTextBoxAngle,
+  FpTextBoxEnd,
+  FpTextBoxStart,
+  Layer,
+  Pts,
+  RenderCache,
+  Stroke,
+  TextEffects,
+  Uuid,
+  SxClass,
+} from "lib/sexpr"
+import { expect, test } from "bun:test"
+
+test("FpTextBox", () => {
+  const [textBox] = SxClass.parse(`
+    (fp_text_box locked "Notes"
+      (start 0 0)
+      (end 10 5)
+      (pts (xy 0 0) (xy 10 0) (xy 10 5) (xy 0 5))
+      (angle 45)
+      (layer F.SilkS)
+      (effects (font (size 1 1) (thickness 0.15)))
+      (stroke (width 0.1) (type solid) (color 0 0 0 1))
+      (uuid 11111111-2222-3333-4444-555555555555)
+      (render_cache "Notes text" 0 0)
+    )
+  `)
+
+  expect(textBox).toBeInstanceOf(FpTextBox)
+  const fpTextBox = textBox as FpTextBox
+
+  expect(fpTextBox.locked).toBe(true)
+  expect(fpTextBox.text).toBe("Notes")
+  expect(fpTextBox.start).toBeInstanceOf(FpTextBoxStart)
+  expect(fpTextBox.start?.x).toBe(0)
+  expect(fpTextBox.end).toBeInstanceOf(FpTextBoxEnd)
+  expect(fpTextBox.end?.y).toBe(5)
+  expect(fpTextBox.pts).toBeInstanceOf(Pts)
+  expect(fpTextBox.pts?.points.length).toBe(4)
+  expect(fpTextBox.angle).toBeInstanceOf(FpTextBoxAngle)
+  expect(fpTextBox.angle?.value).toBe(45)
+  expect(fpTextBox.layer).toBeInstanceOf(Layer)
+  expect(fpTextBox.effects).toBeInstanceOf(TextEffects)
+  expect(fpTextBox.stroke).toBeInstanceOf(Stroke)
+  expect(fpTextBox.uuid).toBeInstanceOf(Uuid)
+  expect(fpTextBox.renderCache).toBeInstanceOf(RenderCache)
+  expect(fpTextBox.renderCache?.text).toBe("Notes text")
+  expect(fpTextBox.renderCache?.angle).toBe(0)
+  expect(fpTextBox.renderCache?.offsetX).toBe(0)
+  expect(fpTextBox.renderCache?.offsetY).toBeUndefined()
+
+  fpTextBox.locked = false
+
+  expect(fpTextBox.getString()).toMatchInlineSnapshot(`
+    "(fp_text_box
+      \"Notes\"
+      (start 0 0)
+      (end 10 5)
+      (pts
+        (xy 0 0)
+        (xy 10 0)
+        (xy 10 5)
+        (xy 0 5)
+      )
+      (angle 45)
+      (layer F.SilkS)
+      (effects
+        (font
+          (size 1 1)
+          (thickness 0.15)
+        )
+      )
+      (stroke
+        (width 0.1)
+        (type solid)
+        (color 0 0 0 1)
+      )
+      (uuid 11111111-2222-3333-4444-555555555555)
+      (render_cache \"Notes text\" 0 0)
+    )"
+  `)
+})

package/tests/sexpr/classes/Image.test.ts

@@ -0,0 +1,50 @@
+import { At, Image, ImageData, ImageScale, Layer, SxClass, Uuid } from "lib/sexpr"
+import { expect, test } from "bun:test"
+
+test("Image", () => {
+  const [image] = SxClass.parse(`
+    (image
+      (at 12.7 25.4 90)
+      (scale 0.75)
+      (layer F.SilkS B.SilkS)
+      (uuid 12345678-1234-1234-1234-123456789abc)
+      (data iVBORw0KGgoAAAANSUhEUgAAAAUA)
+    )
+  `)
+
+  expect(image).toBeInstanceOf(Image)
+  const img = image as Image
+
+  const at = img.position as At
+  expect(at.x).toBe(12.7)
+  expect(at.y).toBe(25.4)
+  expect(at.angle).toBe(90)
+
+  const scale = img.scale as ImageScale
+  expect(scale.value).toBe(0.75)
+
+  const layer = img.layer as Layer
+  expect(layer.names).toEqual(["F.SilkS", "B.SilkS"])
+
+  const uuid = img.uuid as Uuid
+  expect(uuid.value).toBe("12345678-1234-1234-1234-123456789abc")
+
+  const data = img.data as ImageData
+  expect(data.value).toBe("iVBORw0KGgoAAAANSUhEUgAAAAUA")
+
+  img.scale = 1.2
+  img.layer = "F.Cu"
+  img.uuid = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+  img.data = "ZGF0YQ=="
+  img.position = new At([0, 0])
+
+  expect(img.getString()).toMatchInlineSnapshot(`
+    "(image
+      (at 0 0)
+      (scale 1.2)
+      (layer F.Cu)
+      (uuid aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee)
+      (data \"ZGF0YQ==\")
+    )"
+  `)
+})

package/tests/sexpr/classes/KicadSch.test.ts

@@ -0,0 +1,97 @@
+import {
+  KicadSch,
+  Paper,
+  Property,
+  SchematicSymbol,
+  Sheet,
+  SxClass,
+  TitleBlock,
+  Wire,
+} from "lib/sexpr"
+import { expect, test } from "bun:test"
+
+test("KicadSch parse", () => {
+  const [parsed] = SxClass.parse(`
+    (kicad_sch
+      (version 20240101)
+      (generator kicad-cli)
+      (uuid 01234567-89ab-cdef-0123-456789abcdef)
+      (paper A4)
+      (title_block
+        (title "Demo")
+        (company "Example Co")
+      )
+      (property "Sheetfile" "demo.kicad_sch")
+      (sheet
+        (at 0 0 0)
+        (size 100 80)
+        (uuid abcdefab-1234-5678-90ab-abcdefabcdef)
+      )
+      (symbol "Device:R"
+        (at 25.4 12.7)
+        (uuid fedcba98-7654-3210-fedc-ba9876543210)
+      )
+      (wire (pts (xy 0 0) (xy 10 10)))
+    )
+  `)
+
+  expect(parsed).toBeInstanceOf(KicadSch)
+  const schematic = parsed as KicadSch
+
+  expect(schematic.version).toBe(20240101)
+  expect(schematic.generator).toBe("kicad-cli")
+  expect(schematic.uuid?.value).toBe(
+    "01234567-89ab-cdef-0123-456789abcdef",
+  )
+
+  expect(schematic.paper).toBeInstanceOf(Paper)
+  expect(schematic.titleBlock).toBeInstanceOf(TitleBlock)
+  expect(schematic.titleBlock?.title).toBe("Demo")
+  expect(schematic.titleBlock?.company).toBe("Example Co")
+
+  expect(schematic.properties).toHaveLength(1)
+  expect(schematic.properties[0]).toBeInstanceOf(Property)
+  expect(schematic.properties[0]?.key).toBe("Sheetfile")
+  expect(schematic.properties[0]?.value).toBe("demo.kicad_sch")
+
+  expect(schematic.sheets).toHaveLength(1)
+  expect(schematic.sheets[0]).toBeInstanceOf(Sheet)
+
+  expect(schematic.symbols).toHaveLength(1)
+  expect(schematic.symbols[0]).toBeInstanceOf(SchematicSymbol)
+
+  expect(schematic.wires).toHaveLength(1)
+  expect(schematic.wires[0]).toBeInstanceOf(Wire)
+
+  expect(schematic.getString()).toMatchInlineSnapshot(`
+    "(kicad_sch
+      (version 20240101)
+      (generator kicad-cli)
+      (uuid 01234567-89ab-cdef-0123-456789abcdef)
+      (paper
+        A4
+      )
+      (title_block
+        (title "Demo")
+        (company "Example Co")
+      )
+      (property "Sheetfile" "demo.kicad_sch"
+      )
+      (sheet
+        (at 0 0 0)
+        (size 100 80)
+        (uuid abcdefab-1234-5678-90ab-abcdefabcdef)
+      )
+      (symbol "Device:R"
+        (at 25.4 12.7)
+        (uuid fedcba98-7654-3210-fedc-ba9876543210)
+      )
+      (wire
+        (pts
+          (xy 0 0)
+          (xy 10 10)
+        )
+      )
+    )"
+  `)
+})

package/tests/sexpr/classes/Paper.test.ts

@@ -0,0 +1,30 @@
+import { Paper, SxClass } from "lib/sexpr"
+import { expect, test } from "bun:test"
+
+test("Paper standard size", () => {
+  const [paper] = SxClass.parse(`
+    (paper
+      A4
+      portrait
+    )
+  `)
+
+  expect(paper).toBeInstanceOf(Paper)
+
+  const page = paper as Paper
+  expect(page.size).toBe("A4")
+  expect(page.customSize).toBeUndefined()
+  expect(page.isPortrait).toBe(true)
+
+  page.isPortrait = false
+  page.customSize = { width: 210, height: 297 }
+
+  expect(page.size).toBeUndefined()
+  expect(page.customSize).toEqual({ width: 210, height: 297 })
+
+  expect(page.getString()).toMatchInlineSnapshot(`
+    "(paper
+      210 297
+    )"
+  `)
+})

package/tests/sexpr/classes/Property.test.ts

@@ -0,0 +1,48 @@
+import { expect, test } from "bun:test"
+import { At, Property, SxClass } from "lib/sexpr"
+import { parseToPrimitiveSExpr } from "lib/sexpr/parseToPrimitiveSExpr"
+import { expectEqualPrimitiveSExpr } from "../../fixtures/expectEqualPrimitiveSExpr"
+
+test("Property preserves extended attributes", () => {
+  const input = `
+    (property "Reference" "R1"
+      (at 1 2 90)
+      (unlocked yes)
+      (layer "F.SilkS")
+      (hide yes)
+      (uuid 12345678-1234-1234-1234-123456789abc)
+      (effects
+        (font
+          (size 1 1)
+          (thickness 0.15)
+        )
+      )
+    )
+  `
+
+  const [parsed] = SxClass.parse(input)
+  expect(parsed).toBeInstanceOf(Property)
+
+  const property = parsed as Property
+  expect(property.key).toBe("Reference")
+  expect(property.value).toBe("R1")
+  const position = property.position
+  expect(position).toBeInstanceOf(At)
+  if (position instanceof At) {
+    expect(position.x).toBe(1)
+    expect(position.y).toBe(2)
+    expect(position.angle).toBe(90)
+  }
+  expect(property.unlocked).toBe(true)
+  expect(property.layer?.names).toEqual(["F.SilkS"])
+  expect(property.hidden).toBe(true)
+  expect(property.uuid?.value).toBe("12345678-1234-1234-1234-123456789abc")
+  expect(property.effects).toBeDefined()
+
+  const roundTrip = property.getString()
+
+  const originalPrimitive = parseToPrimitiveSExpr(input)
+  const roundTripPrimitive = parseToPrimitiveSExpr(roundTrip)
+
+  expectEqualPrimitiveSExpr(roundTripPrimitive, originalPrimitive)
+})