kicadts 0.0.1

package/lib/sexpr/classes/PadPrimitiveGrArc.ts

@@ -0,0 +1,254 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { Width } from "./Width"
+import { toNumberValue } from "../utils/toNumberValue"
+
+const SUPPORTED_TOKENS = new Set(["start", "mid", "end", "width"])
+
+export class PadPrimitiveGrArc extends SxClass {
+  static override token = "gr_arc"
+  static override parentToken = "primitives"
+  override token = "gr_arc"
+
+  private _sxStart?: PadPrimitiveGrArcStart
+  private _sxMid?: PadPrimitiveGrArcMid
+  private _sxEnd?: PadPrimitiveGrArcEnd
+  private _sxWidth?: Width
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveGrArc {
+    const arc = new PadPrimitiveGrArc()
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
+
+    for (const token of Object.keys(propertyMap)) {
+      if (!SUPPORTED_TOKENS.has(token)) {
+        throw new Error(
+          `pad primitive gr_arc encountered unsupported child token "${token}"`,
+        )
+      }
+    }
+
+    for (const [token, entries] of Object.entries(arrayPropertyMap)) {
+      if (!SUPPORTED_TOKENS.has(token)) {
+        throw new Error(
+          `pad primitive gr_arc encountered unsupported child token "${token}"`,
+        )
+      }
+      if (entries.length > 1) {
+        throw new Error(
+          `pad primitive gr_arc does not support repeated "${token}" tokens`,
+        )
+      }
+    }
+
+    arc._sxStart = propertyMap.start as PadPrimitiveGrArcStart | undefined
+    arc._sxMid = propertyMap.mid as PadPrimitiveGrArcMid | undefined
+    arc._sxEnd = propertyMap.end as PadPrimitiveGrArcEnd | undefined
+    arc._sxWidth = propertyMap.width as Width | undefined
+
+    if (!arc._sxStart) {
+      throw new Error("pad primitive gr_arc requires a start child token")
+    }
+    if (!arc._sxMid) {
+      throw new Error("pad primitive gr_arc requires a mid child token")
+    }
+    if (!arc._sxEnd) {
+      throw new Error("pad primitive gr_arc requires an end child token")
+    }
+
+    return arc
+  }
+
+  get start(): PadPrimitiveGrArcStart | undefined {
+    return this._sxStart
+  }
+
+  set start(
+    value: PadPrimitiveGrArcStart | { x: number; y: number } | undefined,
+  ) {
+    this._sxStart = normalizeArcPoint(value, PadPrimitiveGrArcStart)
+  }
+
+  get mid(): PadPrimitiveGrArcMid | undefined {
+    return this._sxMid
+  }
+
+  set mid(value: PadPrimitiveGrArcMid | { x: number; y: number } | undefined) {
+    this._sxMid = normalizeArcPoint(value, PadPrimitiveGrArcMid)
+  }
+
+  get end(): PadPrimitiveGrArcEnd | undefined {
+    return this._sxEnd
+  }
+
+  set end(value: PadPrimitiveGrArcEnd | { x: number; y: number } | undefined) {
+    this._sxEnd = normalizeArcPoint(value, PadPrimitiveGrArcEnd)
+  }
+
+  get width(): number | undefined {
+    return this._sxWidth?.value
+  }
+
+  set width(value: Width | number | undefined) {
+    if (value === undefined) {
+      this._sxWidth = undefined
+      return
+    }
+    this._sxWidth = value instanceof Width ? value : new Width(value)
+  }
+
+  get widthClass(): Width | undefined {
+    return this._sxWidth
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxStart) children.push(this._sxStart)
+    if (this._sxMid) children.push(this._sxMid)
+    if (this._sxEnd) children.push(this._sxEnd)
+    if (this._sxWidth) children.push(this._sxWidth)
+    return children
+  }
+
+  override getString(): string {
+    const lines = ["(gr_arc"]
+    if (this._sxStart) lines.push(this._sxStart.getStringIndented())
+    if (this._sxMid) lines.push(this._sxMid.getStringIndented())
+    if (this._sxEnd) lines.push(this._sxEnd.getStringIndented())
+    if (this._sxWidth) lines.push(this._sxWidth.getStringIndented())
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(PadPrimitiveGrArc)
+
+type ArcPointConstructor<T extends PadPrimitiveGrArcPoint> = new (
+  x: number,
+  y: number,
+) => T
+
+const normalizeArcPoint = <T extends PadPrimitiveGrArcPoint>(
+  value: T | { x: number; y: number } | undefined,
+  Constructor: ArcPointConstructor<T>,
+): T | undefined => {
+  if (value === undefined) {
+    return undefined
+  }
+  if (value instanceof Constructor) {
+    return value
+  }
+  return new Constructor(value.x, value.y)
+}
+
+abstract class PadPrimitiveGrArcPoint extends SxClass {
+  protected _x: number
+  protected _y: number
+
+  protected constructor(x: number, y: number) {
+    super()
+    this._x = x
+    this._y = 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 `(${this.token} ${this._x} ${this._y})`
+  }
+}
+
+class PadPrimitiveGrArcStart extends PadPrimitiveGrArcPoint {
+  static override token = "start"
+  static override parentToken = "gr_arc"
+  override token = "start"
+
+  constructor(x: number, y: number) {
+    super(x, y)
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveGrArcStart {
+    const [rawX, rawY] = primitiveSexprs
+    const x = toNumberValue(rawX)
+    const y = toNumberValue(rawY)
+
+    if (x === undefined || y === undefined) {
+      throw new Error("pad primitive gr_arc start expects two numeric arguments")
+    }
+
+    return new PadPrimitiveGrArcStart(x, y)
+  }
+}
+SxClass.register(PadPrimitiveGrArcStart)
+
+class PadPrimitiveGrArcMid extends PadPrimitiveGrArcPoint {
+  static override token = "mid"
+  static override parentToken = "gr_arc"
+  override token = "mid"
+
+  constructor(x: number, y: number) {
+    super(x, y)
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveGrArcMid {
+    const [rawX, rawY] = primitiveSexprs
+    const x = toNumberValue(rawX)
+    const y = toNumberValue(rawY)
+
+    if (x === undefined || y === undefined) {
+      throw new Error("pad primitive gr_arc mid expects two numeric arguments")
+    }
+
+    return new PadPrimitiveGrArcMid(x, y)
+  }
+}
+SxClass.register(PadPrimitiveGrArcMid)
+
+class PadPrimitiveGrArcEnd extends PadPrimitiveGrArcPoint {
+  static override token = "end"
+  static override parentToken = "gr_arc"
+  override token = "end"
+
+  constructor(x: number, y: number) {
+    super(x, y)
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveGrArcEnd {
+    const [rawX, rawY] = primitiveSexprs
+    const x = toNumberValue(rawX)
+    const y = toNumberValue(rawY)
+
+    if (x === undefined || y === undefined) {
+      throw new Error("pad primitive gr_arc end expects two numeric arguments")
+    }
+
+    return new PadPrimitiveGrArcEnd(x, y)
+  }
+}
+SxClass.register(PadPrimitiveGrArcEnd)

package/lib/sexpr/classes/PadPrimitiveGrCircle.ts

@@ -0,0 +1,279 @@
+import { SxClass } from "../base-classes/SxClass"
+import { SxPrimitiveBoolean } from "../base-classes/SxPrimitiveBoolean"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { Width } from "./Width"
+import { toNumberValue } from "../utils/toNumberValue"
+
+const SUPPORTED_TOKENS = new Set(["center", "end", "width", "fill"])
+
+export class PadPrimitiveGrCircle extends SxClass {
+  static override token = "gr_circle"
+  static override parentToken = "primitives"
+  override token = "gr_circle"
+
+  private _sxCenter?: PadPrimitiveGrCircleCenter
+  private _sxEnd?: PadPrimitiveGrCircleEnd
+  private _sxWidth?: Width
+  private _sxFill?: PadPrimitiveGrCircleFill
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveGrCircle {
+    const circle = new PadPrimitiveGrCircle()
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
+
+    for (const token of Object.keys(propertyMap)) {
+      if (!SUPPORTED_TOKENS.has(token)) {
+        throw new Error(
+          `pad primitive gr_circle encountered unsupported child token "${token}"`,
+        )
+      }
+    }
+
+    for (const [token, entries] of Object.entries(arrayPropertyMap)) {
+      if (!SUPPORTED_TOKENS.has(token)) {
+        throw new Error(
+          `pad primitive gr_circle encountered unsupported child token "${token}"`,
+        )
+      }
+      if (entries.length > 1) {
+        throw new Error(
+          `pad primitive gr_circle does not support repeated "${token}" tokens`,
+        )
+      }
+    }
+
+    circle._sxCenter = propertyMap.center as
+      | PadPrimitiveGrCircleCenter
+      | undefined
+    circle._sxEnd = propertyMap.end as PadPrimitiveGrCircleEnd | undefined
+    circle._sxWidth = propertyMap.width as Width | undefined
+    circle._sxFill = propertyMap.fill as PadPrimitiveGrCircleFill | undefined
+
+    if (!circle._sxCenter) {
+      throw new Error("pad primitive gr_circle requires a center child token")
+    }
+    if (!circle._sxEnd) {
+      throw new Error("pad primitive gr_circle requires an end child token")
+    }
+
+    return circle
+  }
+
+  get center(): PadPrimitiveGrCircleCenter | undefined {
+    return this._sxCenter
+  }
+
+  set center(
+    value: PadPrimitiveGrCircleCenter | { x: number; y: number } | undefined,
+  ) {
+    this._sxCenter = normalizeCirclePoint(value, PadPrimitiveGrCircleCenter)
+  }
+
+  get end(): PadPrimitiveGrCircleEnd | undefined {
+    return this._sxEnd
+  }
+
+  set end(value: PadPrimitiveGrCircleEnd | { x: number; y: number } | undefined) {
+    this._sxEnd = normalizeCirclePoint(value, PadPrimitiveGrCircleEnd)
+  }
+
+  get width(): number | undefined {
+    return this._sxWidth?.value
+  }
+
+  set width(value: Width | number | undefined) {
+    if (value === undefined) {
+      this._sxWidth = undefined
+      return
+    }
+    this._sxWidth = value instanceof Width ? value : new Width(value)
+  }
+
+  get widthClass(): Width | undefined {
+    return this._sxWidth
+  }
+
+  get fill(): boolean | undefined {
+    return this._sxFill?.value
+  }
+
+  set fill(value: PadPrimitiveGrCircleFill | boolean | undefined) {
+    if (value === undefined) {
+      this._sxFill = undefined
+      return
+    }
+    this._sxFill =
+      value instanceof PadPrimitiveGrCircleFill
+        ? value
+        : new PadPrimitiveGrCircleFill(value)
+  }
+
+  get fillClass(): PadPrimitiveGrCircleFill | undefined {
+    return this._sxFill
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxCenter) children.push(this._sxCenter)
+    if (this._sxEnd) children.push(this._sxEnd)
+    if (this._sxWidth) children.push(this._sxWidth)
+    if (this._sxFill) children.push(this._sxFill)
+    return children
+  }
+
+  override getString(): string {
+    const lines = ["(gr_circle"]
+    if (this._sxCenter) lines.push(this._sxCenter.getStringIndented())
+    if (this._sxEnd) lines.push(this._sxEnd.getStringIndented())
+    if (this._sxWidth) lines.push(this._sxWidth.getStringIndented())
+    if (this._sxFill) lines.push(this._sxFill.getStringIndented())
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(PadPrimitiveGrCircle)
+
+type CirclePointConstructor<T extends PadPrimitiveGrCirclePoint> = new (
+  x: number,
+  y: number,
+) => T
+
+const normalizeCirclePoint = <T extends PadPrimitiveGrCirclePoint>(
+  value: T | { x: number; y: number } | undefined,
+  Constructor: CirclePointConstructor<T>,
+): T | undefined => {
+  if (value === undefined) {
+    return undefined
+  }
+  if (value instanceof Constructor) {
+    return value
+  }
+  return new Constructor(value.x, value.y)
+}
+
+abstract class PadPrimitiveGrCirclePoint extends SxClass {
+  protected _x: number
+  protected _y: number
+
+  protected constructor(x: number, y: number) {
+    super()
+    this._x = x
+    this._y = 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 `(${this.token} ${this._x} ${this._y})`
+  }
+}
+
+class PadPrimitiveGrCircleCenter extends PadPrimitiveGrCirclePoint {
+  static override token = "center"
+  static override parentToken = "gr_circle"
+  override token = "center"
+
+  constructor(x: number, y: number) {
+    super(x, y)
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveGrCircleCenter {
+    const [rawX, rawY] = primitiveSexprs
+    const x = toNumberValue(rawX)
+    const y = toNumberValue(rawY)
+
+    if (x === undefined || y === undefined) {
+      throw new Error(
+        "pad primitive gr_circle center expects two numeric arguments",
+      )
+    }
+
+    return new PadPrimitiveGrCircleCenter(x, y)
+  }
+}
+SxClass.register(PadPrimitiveGrCircleCenter)
+
+class PadPrimitiveGrCircleEnd extends PadPrimitiveGrCirclePoint {
+  static override token = "end"
+  static override parentToken = "gr_circle"
+  override token = "end"
+
+  constructor(x: number, y: number) {
+    super(x, y)
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveGrCircleEnd {
+    const [rawX, rawY] = primitiveSexprs
+    const x = toNumberValue(rawX)
+    const y = toNumberValue(rawY)
+
+    if (x === undefined || y === undefined) {
+      throw new Error(
+        "pad primitive gr_circle end expects two numeric arguments",
+      )
+    }
+
+    return new PadPrimitiveGrCircleEnd(x, y)
+  }
+}
+SxClass.register(PadPrimitiveGrCircleEnd)
+
+class PadPrimitiveGrCircleFill extends SxPrimitiveBoolean {
+  static override token = "fill"
+  static override parentToken = "gr_circle"
+  override token = "fill"
+
+  constructor(value?: boolean) {
+    super(value ?? false)
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveGrCircleFill {
+    const [raw] = primitiveSexprs
+    if (raw === undefined) {
+      return new PadPrimitiveGrCircleFill(false)
+    }
+    if (typeof raw === "boolean") {
+      return new PadPrimitiveGrCircleFill(raw)
+    }
+    if (typeof raw === "string") {
+      const normalized = raw.toLowerCase()
+      if (normalized === "yes" || normalized === "true") {
+        return new PadPrimitiveGrCircleFill(true)
+      }
+      if (normalized === "no" || normalized === "false") {
+        return new PadPrimitiveGrCircleFill(false)
+      }
+    }
+    throw new Error(
+      `pad primitive gr_circle fill expects yes/no or boolean, received ${JSON.stringify(raw)}`,
+    )
+  }
+}
+SxClass.register(PadPrimitiveGrCircleFill)

package/lib/sexpr/classes/PadPrimitiveGrLine.ts

@@ -0,0 +1,126 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { GrLineEnd } from "./GrLineEnd"
+import { GrLineStart } from "./GrLineStart"
+import { Width } from "./Width"
+
+const SUPPORTED_TOKENS = new Set(["start", "end", "width"])
+
+export class PadPrimitiveGrLine extends SxClass {
+  static override token = "gr_line"
+  static override parentToken = "primitives"
+  override token = "gr_line"
+
+  private _sxStart?: GrLineStart
+  private _sxEnd?: GrLineEnd
+  private _sxWidth?: Width
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadPrimitiveGrLine {
+    const line = new PadPrimitiveGrLine()
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
+
+    for (const token of Object.keys(propertyMap)) {
+      if (!SUPPORTED_TOKENS.has(token)) {
+        throw new Error(
+          `pad primitive gr_line encountered unsupported child token "${token}"`,
+        )
+      }
+    }
+
+    for (const [token, entries] of Object.entries(arrayPropertyMap)) {
+      if (!SUPPORTED_TOKENS.has(token)) {
+        throw new Error(
+          `pad primitive gr_line encountered unsupported child token "${token}"`,
+        )
+      }
+      if (entries.length > 1) {
+        throw new Error(
+          `pad primitive gr_line does not support repeated "${token}" tokens`,
+        )
+      }
+    }
+
+    line._sxStart = propertyMap.start as GrLineStart | undefined
+    line._sxEnd = propertyMap.end as GrLineEnd | undefined
+    line._sxWidth = propertyMap.width as Width | undefined
+
+    if (!line._sxStart) {
+      throw new Error("pad primitive gr_line requires a start child token")
+    }
+    if (!line._sxEnd) {
+      throw new Error("pad primitive gr_line requires an end child token")
+    }
+
+    return line
+  }
+
+  get start(): GrLineStart | undefined {
+    return this._sxStart
+  }
+
+  set start(value: GrLineStart | { x: number; y: number } | undefined) {
+    if (value === undefined) {
+      this._sxStart = undefined
+      return
+    }
+    if (value instanceof GrLineStart) {
+      this._sxStart = value
+      return
+    }
+    this._sxStart = new GrLineStart(value.x, value.y)
+  }
+
+  get end(): GrLineEnd | undefined {
+    return this._sxEnd
+  }
+
+  set end(value: GrLineEnd | { x: number; y: number } | undefined) {
+    if (value === undefined) {
+      this._sxEnd = undefined
+      return
+    }
+    if (value instanceof GrLineEnd) {
+      this._sxEnd = value
+      return
+    }
+    this._sxEnd = new GrLineEnd(value.x, value.y)
+  }
+
+  get width(): number | undefined {
+    return this._sxWidth?.value
+  }
+
+  set width(value: Width | number | undefined) {
+    if (value === undefined) {
+      this._sxWidth = undefined
+      return
+    }
+    this._sxWidth = value instanceof Width ? value : new Width(value)
+  }
+
+  get widthClass(): Width | undefined {
+    return this._sxWidth
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxStart) children.push(this._sxStart)
+    if (this._sxEnd) children.push(this._sxEnd)
+    if (this._sxWidth) children.push(this._sxWidth)
+    return children
+  }
+
+  override getString(): string {
+    const lines = ["(gr_line"]
+    if (this._sxStart) lines.push(this._sxStart.getStringIndented())
+    if (this._sxEnd) lines.push(this._sxEnd.getStringIndented())
+    if (this._sxWidth) lines.push(this._sxWidth.getStringIndented())
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(PadPrimitiveGrLine)