kicadts 0.0.2 → 0.0.4

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

@@ -1,78 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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)
-})