kicadts 0.0.1

package/lib/sexpr/classes/PadPrimitives.ts

@@ -0,0 +1,289 @@
+import { SxClass } from "../base-classes/SxClass"
+import { SxPrimitiveBoolean } from "../base-classes/SxPrimitiveBoolean"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { Pts } from "./Pts"
+import { Width } from "./Width"
+import { PadPrimitiveGrLine } from "./PadPrimitiveGrLine"
+import { PadPrimitiveGrArc } from "./PadPrimitiveGrArc"
+import { PadPrimitiveGrCircle } from "./PadPrimitiveGrCircle"
+
+type PadPrimitiveGraphic =
+  | PadPrimitiveGrPoly
+  | PadPrimitiveGrLine
+  | PadPrimitiveGrArc
+  | PadPrimitiveGrCircle
+
+export class PadPrimitives extends SxClass {
+  static override token = "primitives"
+  static override parentToken = "pad"
+  override token = "primitives"
+
+  private _graphics: PadPrimitiveGraphic[] = []
+  private _sxWidth?: Width
+  private _sxFill?: PadPrimitivesFill
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitives {
+    const primitives = new PadPrimitives()
+
+    for (const primitive of primitiveSexprs) {
+      if (!Array.isArray(primitive) || primitive.length === 0) {
+        throw new Error(
+          `pad primitives encountered invalid child expression: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      const parsed = SxClass.parsePrimitiveSexpr(primitive, {
+        parentToken: this.token,
+      })
+
+      if (!(parsed instanceof SxClass)) {
+        throw new Error(
+          `pad primitives child did not resolve to an SxClass: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      if (parsed instanceof Width) {
+        if (primitives._sxWidth) {
+          throw new Error("pad primitives encountered duplicate width tokens")
+        }
+        primitives._sxWidth = parsed
+        continue
+      }
+
+      if (parsed instanceof PadPrimitivesFill) {
+        if (primitives._sxFill) {
+          throw new Error("pad primitives encountered duplicate fill tokens")
+        }
+        primitives._sxFill = parsed
+        continue
+      }
+
+      if (parsed instanceof PadPrimitiveGrPoly) {
+        primitives._graphics.push(parsed)
+        continue
+      }
+
+      if (parsed instanceof PadPrimitiveGrLine) {
+        primitives._graphics.push(parsed)
+        continue
+      }
+
+      if (parsed instanceof PadPrimitiveGrArc) {
+        primitives._graphics.push(parsed)
+        continue
+      }
+
+      if (parsed instanceof PadPrimitiveGrCircle) {
+        primitives._graphics.push(parsed)
+        continue
+      }
+
+      throw new Error(`pad primitives encountered unsupported token "${parsed.token}"`)
+    }
+
+    return primitives
+  }
+
+  get graphics(): PadPrimitiveGraphic[] {
+    return [...this._graphics]
+  }
+
+  set graphics(value: PadPrimitiveGraphic[]) {
+    this._graphics = [...value]
+  }
+
+  addGraphic(graphic: PadPrimitiveGraphic) {
+    this._graphics.push(graphic)
+  }
+
+  get width(): number | undefined {
+    return this._sxWidth?.value
+  }
+
+  set width(value: number | undefined) {
+    this._sxWidth = value === undefined ? undefined : new Width(value)
+  }
+
+  get fill(): boolean | undefined {
+    return this._sxFill?.value
+  }
+
+  set fill(value: boolean | undefined) {
+    this._sxFill =
+      value === undefined ? undefined : new PadPrimitivesFill({ value })
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    children.push(...this._graphics)
+    if (this._sxWidth) children.push(this._sxWidth)
+    if (this._sxFill) children.push(this._sxFill)
+    return children
+  }
+}
+SxClass.register(PadPrimitives)
+
+class PadPrimitivesFill extends SxPrimitiveBoolean {
+  static override token = "fill"
+  static override parentToken = "primitives"
+  override token = "fill"
+
+  constructor(options: { value?: boolean } = {}) {
+    super(options.value ?? false)
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitivesFill {
+    const [raw] = primitiveSexprs
+    const normalized = typeof raw === "string" ? raw.toLowerCase() : raw
+    if (normalized === undefined) {
+      return new PadPrimitivesFill({ value: false })
+    }
+    if (normalized === "yes") {
+      return new PadPrimitivesFill({ value: true })
+    }
+    if (normalized === "no") {
+      return new PadPrimitivesFill({ value: false })
+    }
+    if (typeof normalized === "boolean") {
+      return new PadPrimitivesFill({ value: normalized })
+    }
+    throw new Error(
+      `pad primitives fill expects yes/no or boolean, received ${JSON.stringify(raw)}`,
+    )
+  }
+}
+SxClass.register(PadPrimitivesFill)
+
+export class PadPrimitiveGrPoly extends SxClass {
+  static override token = "gr_poly"
+  static override parentToken = "primitives"
+  override token = "gr_poly"
+
+  private _contours: Pts[] = []
+  private _sxWidth?: Width
+  private _sxFill?: PadPrimitiveFill
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveGrPoly {
+    const polygon = new PadPrimitiveGrPoly()
+
+    for (const primitive of primitiveSexprs) {
+      if (!Array.isArray(primitive) || primitive.length === 0) {
+        throw new Error(
+          `gr_poly primitive encountered invalid child: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      const parsed = SxClass.parsePrimitiveSexpr(primitive, {
+        parentToken: this.token,
+      })
+
+      if (!(parsed instanceof SxClass)) {
+        throw new Error(
+          `gr_poly primitive child did not resolve to an SxClass: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      if (parsed instanceof Pts) {
+        polygon._contours.push(parsed)
+        continue
+      }
+
+      if (parsed instanceof Width) {
+        if (polygon._sxWidth) {
+          throw new Error("gr_poly encountered duplicate width tokens")
+        }
+        polygon._sxWidth = parsed
+        continue
+      }
+
+      if (parsed instanceof PadPrimitiveFill) {
+        if (polygon._sxFill) {
+          throw new Error("gr_poly encountered duplicate fill tokens")
+        }
+        polygon._sxFill = parsed
+        continue
+      }
+
+      throw new Error(`gr_poly encountered unsupported token "${parsed.token}"`)
+    }
+
+    if (polygon._contours.length === 0) {
+      throw new Error("gr_poly requires at least one pts child")
+    }
+
+    return polygon
+  }
+
+  get contours(): Pts[] {
+    return [...this._contours]
+  }
+
+  set contours(value: Pts[]) {
+    this._contours = [...value]
+  }
+
+  get width(): number | undefined {
+    return this._sxWidth?.value
+  }
+
+  set width(value: number | undefined) {
+    this._sxWidth = value === undefined ? undefined : new Width(value)
+  }
+
+  get filled(): boolean | undefined {
+    return this._sxFill?.value
+  }
+
+  set filled(value: boolean | undefined) {
+    this._sxFill =
+      value === undefined ? undefined : new PadPrimitiveFill({ value })
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    children.push(...this._contours)
+    if (this._sxWidth) children.push(this._sxWidth)
+    if (this._sxFill) children.push(this._sxFill)
+    return children
+  }
+}
+SxClass.register(PadPrimitiveGrPoly)
+
+class PadPrimitiveFill extends SxPrimitiveBoolean {
+  static override token = "fill"
+  static override parentToken = "gr_poly"
+  override token = "fill"
+
+  constructor(options: { value?: boolean } = {}) {
+    super(options.value ?? false)
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveFill {
+    const [raw] = primitiveSexprs
+    if (raw === undefined) {
+      return new PadPrimitiveFill({ value: false })
+    }
+    if (typeof raw === "boolean") {
+      return new PadPrimitiveFill({ value: raw })
+    }
+    if (typeof raw === "string") {
+      return new PadPrimitiveFill({ value: raw.toLowerCase() === "yes" })
+    }
+    throw new Error(
+      `gr_poly fill expects yes/no or boolean, received ${JSON.stringify(raw)}`,
+    )
+  }
+
+  override getString(): string {
+    return `(fill ${this.value ? "yes" : "no"})`
+  }
+}
+SxClass.register(PadPrimitiveFill)

package/lib/sexpr/classes/PadRectDelta.ts

@@ -0,0 +1,57 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { toNumberValue } from "../utils/toNumberValue"
+
+export class PadRectDelta extends SxClass {
+  static override token = "rect_delta"
+  static override parentToken = "pad"
+  override token = "rect_delta"
+
+  private _x: number
+  private _y: number
+
+  constructor(x = 0, y = 0) {
+    super()
+    this._x = x
+    this._y = y
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadRectDelta {
+    const [rawX, rawY] = primitiveSexprs
+    const x = toNumberValue(rawX)
+    const y = toNumberValue(rawY)
+
+    if (x === undefined || y === undefined) {
+      throw new Error("pad rect_delta expects two numeric arguments")
+    }
+
+    return new PadRectDelta(x, y)
+  }
+
+  get x(): number {
+    return this._x
+  }
+
+  set x(value: number) {
+    this._x = value
+  }
+
+  get y(): number {
+    return this._y
+  }
+
+  set y(value: number) {
+    this._y = value
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(rect_delta ${this._x} ${this._y})`
+  }
+}
+SxClass.register(PadRectDelta)

package/lib/sexpr/classes/PadRoundrectRratio.ts

@@ -0,0 +1,9 @@
+import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
+import { SxClass } from "../base-classes/SxClass"
+
+export class PadRoundrectRratio extends SxPrimitiveNumber {
+  static override token = "roundrect_rratio"
+  static override parentToken = "pad"
+  token = "roundrect_rratio"
+}
+SxClass.register(PadRoundrectRratio)

package/lib/sexpr/classes/PadSize.ts

@@ -0,0 +1,54 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { toNumberValue } from "../utils/toNumberValue"
+
+export class PadSize extends SxClass {
+  static override token = "size"
+  static override parentToken = "pad"
+  token = "size"
+
+  private _width: number
+  private _height: number
+
+  constructor(width: number, height: number) {
+    super()
+    this._width = width
+    this._height = height
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadSize {
+    const width = toNumberValue(primitiveSexprs[0])
+    const height = toNumberValue(primitiveSexprs[1])
+    if (width === undefined || height === undefined) {
+      throw new Error("size requires width and height numeric values")
+    }
+    return new PadSize(width, height)
+  }
+
+  get width(): number {
+    return this._width
+  }
+
+  set width(value: number) {
+    this._width = value
+  }
+
+  get height(): number {
+    return this._height
+  }
+
+  set height(value: number) {
+    this._height = value
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(size ${this._width} ${this._height})`
+  }
+}
+SxClass.register(PadSize)

package/lib/sexpr/classes/PadSolderMaskMargin.ts

@@ -0,0 +1,9 @@
+import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
+import { SxClass } from "../base-classes/SxClass"
+
+export class PadSolderMaskMargin extends SxPrimitiveNumber {
+  static override token = "solder_mask_margin"
+  static override parentToken = "pad"
+  token = "solder_mask_margin"
+}
+SxClass.register(PadSolderMaskMargin)

package/lib/sexpr/classes/PadSolderPasteMargin.ts

@@ -0,0 +1,9 @@
+import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
+import { SxClass } from "../base-classes/SxClass"
+
+export class PadSolderPasteMargin extends SxPrimitiveNumber {
+  static override token = "solder_paste_margin"
+  static override parentToken = "pad"
+  token = "solder_paste_margin"
+}
+SxClass.register(PadSolderPasteMargin)

package/lib/sexpr/classes/PadSolderPasteMarginRatio.ts

@@ -0,0 +1,9 @@
+import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
+import { SxClass } from "../base-classes/SxClass"
+
+export class PadSolderPasteMarginRatio extends SxPrimitiveNumber {
+  static override token = "solder_paste_margin_ratio"
+  static override parentToken = "pad"
+  token = "solder_paste_margin_ratio"
+}
+SxClass.register(PadSolderPasteMarginRatio)

package/lib/sexpr/classes/PadTeardrops.ts

@@ -0,0 +1,208 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { toNumberValue } from "../utils/toNumberValue"
+import { parseYesNo } from "../utils/parseYesNo"
+
+type NumericTeardropProperty =
+  | "bestLengthRatio"
+  | "maxLength"
+  | "bestWidthRatio"
+  | "maxWidth"
+  | "filterRatio"
+
+type BooleanTeardropProperty =
+  | "curvedEdges"
+  | "enabled"
+  | "allowTwoSegments"
+  | "preferZoneConnections"
+
+const NUMERIC_TOKENS = new Map<string, NumericTeardropProperty>([
+  ["best_length_ratio", "bestLengthRatio"],
+  ["max_length", "maxLength"],
+  ["best_width_ratio", "bestWidthRatio"],
+  ["max_width", "maxWidth"],
+  ["filter_ratio", "filterRatio"],
+])
+
+const BOOLEAN_TOKENS = new Map<string, BooleanTeardropProperty>([
+  ["curved_edges", "curvedEdges"],
+  ["enabled", "enabled"],
+  ["allow_two_segments", "allowTwoSegments"],
+  ["prefer_zone_connections", "preferZoneConnections"],
+])
+
+export class PadTeardrops extends SxClass {
+  static override token = "teardrops"
+  static override parentToken = "pad"
+  override token = "teardrops"
+
+  private _bestLengthRatio?: number
+  private _maxLength?: number
+  private _bestWidthRatio?: number
+  private _maxWidth?: number
+  private _filterRatio?: number
+  private _curvedEdges?: boolean
+  private _enabled?: boolean
+  private _allowTwoSegments?: boolean
+  private _preferZoneConnections?: boolean
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadTeardrops {
+    const teardrops = new PadTeardrops()
+
+    for (const primitive of primitiveSexprs) {
+      if (!Array.isArray(primitive) || primitive.length === 0) {
+        throw new Error(
+          `teardrops encountered invalid child expression: ${JSON.stringify(primitive)}`,
+        )
+      }
+      const [rawToken, rawValue] = primitive
+      if (typeof rawToken !== "string") {
+        throw new Error(
+          `teardrops encountered non-string token: ${JSON.stringify(rawToken)}`,
+        )
+      }
+
+      if (NUMERIC_TOKENS.has(rawToken)) {
+        const property = NUMERIC_TOKENS.get(rawToken)!
+        const numeric = toNumberValue(rawValue)
+        if (numeric === undefined) {
+          throw new Error(
+            `teardrops ${rawToken} expects a numeric value, received ${JSON.stringify(rawValue)}`,
+          )
+        }
+        teardrops[property] = numeric
+        continue
+      }
+
+      if (BOOLEAN_TOKENS.has(rawToken)) {
+        const property = BOOLEAN_TOKENS.get(rawToken)!
+        const booleanValue = parseYesNo(rawValue)
+        if (booleanValue === undefined) {
+          throw new Error(
+            `teardrops ${rawToken} expects yes/no, received ${JSON.stringify(rawValue)}`,
+          )
+        }
+        teardrops[property] = booleanValue
+        continue
+      }
+
+      throw new Error(`teardrops encountered unsupported token "${rawToken}"`)
+    }
+
+    return teardrops
+  }
+
+  get bestLengthRatio(): number | undefined {
+    return this._bestLengthRatio
+  }
+
+  set bestLengthRatio(value: number | undefined) {
+    this._bestLengthRatio = value
+  }
+
+  get maxLength(): number | undefined {
+    return this._maxLength
+  }
+
+  set maxLength(value: number | undefined) {
+    this._maxLength = value
+  }
+
+  get bestWidthRatio(): number | undefined {
+    return this._bestWidthRatio
+  }
+
+  set bestWidthRatio(value: number | undefined) {
+    this._bestWidthRatio = value
+  }
+
+  get maxWidth(): number | undefined {
+    return this._maxWidth
+  }
+
+  set maxWidth(value: number | undefined) {
+    this._maxWidth = value
+  }
+
+  get filterRatio(): number | undefined {
+    return this._filterRatio
+  }
+
+  set filterRatio(value: number | undefined) {
+    this._filterRatio = value
+  }
+
+  get curvedEdges(): boolean | undefined {
+    return this._curvedEdges
+  }
+
+  set curvedEdges(value: boolean | undefined) {
+    this._curvedEdges = value
+  }
+
+  get enabled(): boolean | undefined {
+    return this._enabled
+  }
+
+  set enabled(value: boolean | undefined) {
+    this._enabled = value
+  }
+
+  get allowTwoSegments(): boolean | undefined {
+    return this._allowTwoSegments
+  }
+
+  set allowTwoSegments(value: boolean | undefined) {
+    this._allowTwoSegments = value
+  }
+
+  get preferZoneConnections(): boolean | undefined {
+    return this._preferZoneConnections
+  }
+
+  set preferZoneConnections(value: boolean | undefined) {
+    this._preferZoneConnections = value
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    const lines = ["(teardrops"]
+    if (this._bestLengthRatio !== undefined) {
+      lines.push(`  (best_length_ratio ${this._bestLengthRatio})`)
+    }
+    if (this._maxLength !== undefined) {
+      lines.push(`  (max_length ${this._maxLength})`)
+    }
+    if (this._bestWidthRatio !== undefined) {
+      lines.push(`  (best_width_ratio ${this._bestWidthRatio})`)
+    }
+    if (this._maxWidth !== undefined) {
+      lines.push(`  (max_width ${this._maxWidth})`)
+    }
+    if (this._curvedEdges !== undefined) {
+      lines.push(`  (curved_edges ${this._curvedEdges ? "yes" : "no"})`)
+    }
+    if (this._filterRatio !== undefined) {
+      lines.push(`  (filter_ratio ${this._filterRatio})`)
+    }
+    if (this._enabled !== undefined) {
+      lines.push(`  (enabled ${this._enabled ? "yes" : "no"})`)
+    }
+    if (this._allowTwoSegments !== undefined) {
+      lines.push(`  (allow_two_segments ${this._allowTwoSegments ? "yes" : "no"})`)
+    }
+    if (this._preferZoneConnections !== undefined) {
+      lines.push(
+        `  (prefer_zone_connections ${this._preferZoneConnections ? "yes" : "no"})`,
+      )
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(PadTeardrops)

package/lib/sexpr/classes/PadThermalBridgeAngle.ts

@@ -0,0 +1,9 @@
+import { SxClass } from "../base-classes/SxClass"
+import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
+
+export class PadThermalBridgeAngle extends SxPrimitiveNumber {
+  static override token = "thermal_bridge_angle"
+  static override parentToken = "pad"
+  override token = "thermal_bridge_angle"
+}
+SxClass.register(PadThermalBridgeAngle)

package/lib/sexpr/classes/PadThermalGap.ts

@@ -0,0 +1,9 @@
+import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
+import { SxClass } from "../base-classes/SxClass"
+
+export class PadThermalGap extends SxPrimitiveNumber {
+  static override token = "thermal_gap"
+  static override parentToken = "pad"
+  token = "thermal_gap"
+}
+SxClass.register(PadThermalGap)

package/lib/sexpr/classes/PadThermalWidth.ts

@@ -0,0 +1,9 @@
+import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
+import { SxClass } from "../base-classes/SxClass"
+
+export class PadThermalWidth extends SxPrimitiveNumber {
+  static override token = "thermal_width"
+  static override parentToken = "pad"
+  token = "thermal_width"
+}
+SxClass.register(PadThermalWidth)

package/lib/sexpr/classes/PadZoneConnect.ts

@@ -0,0 +1,9 @@
+import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
+import { SxClass } from "../base-classes/SxClass"
+
+export class PadZoneConnect extends SxPrimitiveNumber {
+  static override token = "zone_connect"
+  static override parentToken = "pad"
+  token = "zone_connect"
+}
+SxClass.register(PadZoneConnect)