kicadts 0.0.1

package/lib/sexpr/classes/NoConnect.ts

@@ -0,0 +1,73 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { At } from "./At"
+import { Uuid } from "./Uuid"
+
+const SUPPORTED_TOKENS = new Set(["at", "uuid"])
+
+export class NoConnect extends SxClass {
+  static override token = "no_connect"
+  static override parentToken = "kicad_sch"
+  override token = "no_connect"
+
+  private _sxAt?: At
+  private _sxUuid?: Uuid
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): NoConnect {
+    const noConnect = new NoConnect()
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
+
+    if (Object.keys(arrayPropertyMap).length > 0) {
+      const tokens = Object.keys(arrayPropertyMap).join(", ")
+      throw new Error(
+        `no_connect does not support repeated child tokens: ${tokens}`,
+      )
+    }
+
+    const unsupportedTokens = Object.keys(propertyMap).filter(
+      (token) => !SUPPORTED_TOKENS.has(token),
+    )
+    if (unsupportedTokens.length > 0) {
+      throw new Error(
+        `Unsupported child tokens inside no_connect expression: ${unsupportedTokens.join(", ")}`,
+      )
+    }
+
+    noConnect._sxAt = propertyMap.at as At | undefined
+    noConnect._sxUuid = propertyMap.uuid as Uuid | undefined
+
+    return noConnect
+  }
+
+  get at(): At | undefined {
+    return this._sxAt
+  }
+
+  set at(value: At | undefined) {
+    this._sxAt = value
+  }
+
+  get uuid(): Uuid | undefined {
+    return this._sxUuid
+  }
+
+  set uuid(value: Uuid | string | undefined) {
+    if (value === undefined) {
+      this._sxUuid = undefined
+      return
+    }
+    this._sxUuid = value instanceof Uuid ? value : new Uuid(value)
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxAt) children.push(this._sxAt)
+    if (this._sxUuid) children.push(this._sxUuid)
+    return children
+  }
+}
+SxClass.register(NoConnect)

package/lib/sexpr/classes/OnBoard.ts

@@ -0,0 +1,8 @@
+import { SxClass } from "../base-classes/SxClass"
+import { SxPrimitiveBoolean } from "../base-classes/SxPrimitiveBoolean"
+
+export class OnBoard extends SxPrimitiveBoolean {
+  static override token = "on_board"
+  token = "on_board"
+}
+SxClass.register(OnBoard)

package/lib/sexpr/classes/PadChamfer.ts

@@ -0,0 +1,50 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { printSExpr } from "../parseToPrimitiveSExpr"
+import { toStringValue } from "../utils/toStringValue"
+
+export class PadChamfer extends SxClass {
+  static override token = "chamfer"
+  static override parentToken = "pad"
+  token = "chamfer"
+
+  private _corners: string[] = []
+
+  constructor(corners: string[]) {
+    super()
+    this.corners = corners
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadChamfer {
+    const corners = primitiveSexprs.map((primitive) => {
+      const corner = toStringValue(primitive)
+      if (corner === undefined) {
+        return printSExpr(primitive)
+      }
+      return corner
+    })
+    return new PadChamfer(corners)
+  }
+
+  get corners(): string[] {
+    return [...this._corners]
+  }
+
+  set corners(values: string[]) {
+    this._corners = values.map((value) => String(value))
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    if (this._corners.length === 0) {
+      return "(chamfer)"
+    }
+    return `(chamfer ${this._corners.join(" ")})`
+  }
+}
+SxClass.register(PadChamfer)

package/lib/sexpr/classes/PadChamferRatio.ts

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

package/lib/sexpr/classes/PadClearance.ts

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

package/lib/sexpr/classes/PadDieLength.ts

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

package/lib/sexpr/classes/PadDrill.ts

@@ -0,0 +1,145 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { printSExpr } from "../parseToPrimitiveSExpr"
+import { toNumberValue } from "../utils/toNumberValue"
+import { PadDrillOffset } from "./PadDrillOffset"
+
+export class PadDrill extends SxClass {
+  static override token = "drill"
+  static override parentToken = "pad"
+  token = "drill"
+
+  private _oval = false
+  private _diameter: number
+  private _width?: number
+  private _sxOffset?: PadDrillOffset
+
+  constructor({
+    oval = false,
+    diameter,
+    width,
+    offset,
+  }: {
+    oval?: boolean
+    diameter: number
+    width?: number
+    offset?: PadDrillOffset | { x: number; y: number }
+  }) {
+    super()
+    this._oval = oval
+    this._diameter = diameter
+    this._width = width
+    if (offset instanceof PadDrillOffset) {
+      this._sxOffset = offset
+    } else if (offset) {
+      this._sxOffset = new PadDrillOffset(offset.x, offset.y)
+    }
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadDrill {
+    const remaining = [...primitiveSexprs]
+    let oval = false
+    if (remaining[0] === "oval") {
+      oval = true
+      remaining.shift()
+    }
+
+    const diameter = toNumberValue(remaining.shift())
+    if (diameter === undefined) {
+      throw new Error("drill requires a diameter value")
+    }
+
+    let width: number | undefined
+    const potentialWidth = toNumberValue(remaining[0])
+    if (potentialWidth !== undefined) {
+      width = potentialWidth
+      remaining.shift()
+    }
+
+    const drill = new PadDrill({ oval, diameter, width })
+
+    for (const primitive of remaining) {
+      if (!Array.isArray(primitive)) {
+        throw new Error(
+          `drill encountered unexpected primitive child: ${JSON.stringify(primitive)}`,
+        )
+      }
+      const parsed = SxClass.parsePrimitiveSexpr(primitive, {
+        parentToken: this.token,
+      })
+      if (!(parsed instanceof PadDrillOffset)) {
+        throw new Error(
+          `drill encountered unsupported child token: ${printSExpr(primitive)}`,
+        )
+      }
+      if (drill._sxOffset) {
+        throw new Error("drill does not support multiple offset children")
+      }
+      drill._sxOffset = parsed
+    }
+
+    return drill
+  }
+
+  get oval(): boolean {
+    return this._oval
+  }
+
+  set oval(value: boolean) {
+    this._oval = value
+  }
+
+  get diameter(): number {
+    return this._diameter
+  }
+
+  set diameter(value: number) {
+    this._diameter = value
+  }
+
+  get width(): number | undefined {
+    return this._width
+  }
+
+  set width(value: number | undefined) {
+    this._width = value
+  }
+
+  get offset(): PadDrillOffset | undefined {
+    return this._sxOffset
+  }
+
+  set offset(value: PadDrillOffset | { x: number; y: number } | undefined) {
+    if (value === undefined) {
+      this._sxOffset = undefined
+      return
+    }
+    this._sxOffset =
+      value instanceof PadDrillOffset
+        ? value
+        : new PadDrillOffset(value.x, value.y)
+  }
+
+  override getChildren(): SxClass[] {
+    return this._sxOffset ? [this._sxOffset] : []
+  }
+
+  override getString(): string {
+    const tokens: string[] = []
+    if (this._oval) tokens.push("oval")
+    tokens.push(String(this._diameter))
+    if (this._width !== undefined) tokens.push(String(this._width))
+
+    if (!this._sxOffset) {
+      return `(drill ${tokens.join(" ")})`
+    }
+
+    const lines = [`(drill ${tokens.join(" ")}`]
+    lines.push(this._sxOffset.getStringIndented())
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(PadDrill)

package/lib/sexpr/classes/PadDrillOffset.ts

@@ -0,0 +1,54 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { toNumberValue } from "../utils/toNumberValue"
+
+export class PadDrillOffset extends SxClass {
+  static override token = "offset"
+  static override parentToken = "drill"
+  token = "offset"
+
+  private _x: number
+  private _y: number
+
+  constructor(x: number, y: number) {
+    super()
+    this._x = x
+    this._y = y
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadDrillOffset {
+    const x = toNumberValue(primitiveSexprs[0])
+    const y = toNumberValue(primitiveSexprs[1])
+    if (x === undefined || y === undefined) {
+      throw new Error("drill offset requires x and y numeric values")
+    }
+    return new PadDrillOffset(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 `(offset ${this._x} ${this._y})`
+  }
+}
+SxClass.register(PadDrillOffset)

package/lib/sexpr/classes/PadLayers.ts

@@ -0,0 +1,59 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { printSExpr } from "../parseToPrimitiveSExpr"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { toStringValue } from "../utils/toStringValue"
+
+export class PadLayers extends SxClass {
+  static override token = "layers"
+  static override parentToken = "pad"
+  token = "layers"
+
+  private _layers: string[] = []
+
+  constructor(layers: string[]) {
+    super()
+    this.layers = layers
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadLayers {
+    const layers = primitiveSexprs.map((primitive) => {
+      const value = toStringValue(primitive)
+      if (value === undefined) {
+        return printSExpr(primitive)
+      }
+      return value
+    })
+    return new PadLayers(layers)
+  }
+
+  get layers(): string[] {
+    return [...this._layers]
+  }
+
+  set layers(values: string[]) {
+    this._layers = values.map((value) => String(value))
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    if (this._layers.length === 0) {
+      return "(layers)"
+    }
+    const rendered = this._layers
+      .map((layer) => {
+        if (/^[^\s()"]+$/u.test(layer) && !["nil", "#t", "#f"].includes(layer)) {
+          return layer
+        }
+        return quoteSExprString(layer)
+      })
+      .join(" ")
+    return `(layers ${rendered})`
+  }
+}
+SxClass.register(PadLayers)

package/lib/sexpr/classes/PadNet.ts

@@ -0,0 +1,56 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { toNumberValue } from "../utils/toNumberValue"
+import { toStringValue } from "../utils/toStringValue"
+
+export class PadNet extends SxClass {
+  static override token = "net"
+  static override parentToken = "pad"
+  token = "net"
+
+  private _id: number
+  private _name: string
+
+  constructor(id: number, name: string) {
+    super()
+    this._id = id
+    this._name = name
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadNet {
+    const id = toNumberValue(primitiveSexprs[0])
+    const name = toStringValue(primitiveSexprs[1])
+    if (id === undefined || name === undefined) {
+      throw new Error("pad net requires numeric id and string name")
+    }
+    return new PadNet(id, name)
+  }
+
+  get id(): number {
+    return this._id
+  }
+
+  set id(value: number) {
+    this._id = value
+  }
+
+  get name(): string {
+    return this._name
+  }
+
+  set name(value: string) {
+    this._name = value
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(net ${this._id} ${quoteSExprString(this._name)})`
+  }
+}
+SxClass.register(PadNet)

package/lib/sexpr/classes/PadOptions.ts

@@ -0,0 +1,182 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { toStringValue } from "../utils/toStringValue"
+
+export type PadOptionsClearanceType = "outline" | "convexhull"
+export type PadOptionsAnchorShape = "rect" | "circle"
+
+const CLEARANCE_TYPES: PadOptionsClearanceType[] = [
+  "outline",
+  "convexhull",
+]
+
+const ANCHOR_SHAPES: PadOptionsAnchorShape[] = ["rect", "circle"]
+
+export class PadOptions extends SxClass {
+  static override token = "options"
+  static override parentToken = "pad"
+  override token = "options"
+
+  private _sxClearance?: PadOptionsClearance
+  private _sxAnchor?: PadOptionsAnchor
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadOptions {
+    const options = new PadOptions()
+
+    for (const primitive of primitiveSexprs) {
+      if (!Array.isArray(primitive) || primitive.length === 0) {
+        throw new Error(
+          `pad options encountered invalid child expression: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      const parsed = SxClass.parsePrimitiveSexpr(primitive, {
+        parentToken: this.token,
+      })
+
+      if (!(parsed instanceof SxClass)) {
+        throw new Error(
+          `pad options child did not resolve to an SxClass: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      if (parsed instanceof PadOptionsClearance) {
+        if (options._sxClearance) {
+          throw new Error("pad options encountered duplicate clearance tokens")
+        }
+        options._sxClearance = parsed
+        continue
+      }
+
+      if (parsed instanceof PadOptionsAnchor) {
+        if (options._sxAnchor) {
+          throw new Error("pad options encountered duplicate anchor tokens")
+        }
+        options._sxAnchor = parsed
+        continue
+      }
+
+      throw new Error(`pad options encountered unsupported token "${parsed.token}"`)
+    }
+
+    return options
+  }
+
+  get clearance(): PadOptionsClearanceType | undefined {
+    return this._sxClearance?.type
+  }
+
+  set clearance(value: PadOptionsClearanceType | undefined) {
+    this._sxClearance = value ? new PadOptionsClearance(value) : undefined
+  }
+
+  get anchor(): PadOptionsAnchorShape | undefined {
+    return this._sxAnchor?.shape
+  }
+
+  set anchor(value: PadOptionsAnchorShape | undefined) {
+    this._sxAnchor = value ? new PadOptionsAnchor(value) : undefined
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxClearance) children.push(this._sxClearance)
+    if (this._sxAnchor) children.push(this._sxAnchor)
+    return children
+  }
+}
+SxClass.register(PadOptions)
+
+class PadOptionsClearance extends SxClass {
+  static override token = "clearance"
+  static override parentToken = "options"
+  override token = "clearance"
+
+  private _type: PadOptionsClearanceType
+
+  constructor(type: PadOptionsClearanceType) {
+    super()
+    this._type = type
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadOptionsClearance {
+    const [raw] = primitiveSexprs
+    const stringValue = toStringValue(raw)
+    if (stringValue === undefined) {
+      throw new Error("pad options clearance requires a string value")
+    }
+    if (!CLEARANCE_TYPES.includes(stringValue as PadOptionsClearanceType)) {
+      throw new Error(
+        `pad options clearance must be one of ${CLEARANCE_TYPES.join(", ")}`,
+      )
+    }
+    return new PadOptionsClearance(stringValue as PadOptionsClearanceType)
+  }
+
+  get type(): PadOptionsClearanceType {
+    return this._type
+  }
+
+  set type(value: PadOptionsClearanceType) {
+    this._type = value
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(clearance ${this._type})`
+  }
+}
+SxClass.register(PadOptionsClearance)
+
+class PadOptionsAnchor extends SxClass {
+  static override token = "anchor"
+  static override parentToken = "options"
+  override token = "anchor"
+
+  private _shape: PadOptionsAnchorShape
+
+  constructor(shape: PadOptionsAnchorShape) {
+    super()
+    this._shape = shape
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): PadOptionsAnchor {
+    const [raw] = primitiveSexprs
+    const stringValue = toStringValue(raw)
+    if (stringValue === undefined) {
+      throw new Error("pad options anchor requires a string value")
+    }
+    if (!ANCHOR_SHAPES.includes(stringValue as PadOptionsAnchorShape)) {
+      throw new Error(
+        `pad options anchor must be one of ${ANCHOR_SHAPES.join(", ")}`,
+      )
+    }
+    return new PadOptionsAnchor(stringValue as PadOptionsAnchorShape)
+  }
+
+  get shape(): PadOptionsAnchorShape {
+    return this._shape
+  }
+
+  set shape(value: PadOptionsAnchorShape) {
+    this._shape = value
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(anchor ${this._shape})`
+  }
+}
+SxClass.register(PadOptionsAnchor)

package/lib/sexpr/classes/PadPinFunction.ts

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

package/lib/sexpr/classes/PadPinType.ts

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