kicadts 0.0.1

package/lib/sexpr/base-classes/SxPrimitiveBoolean.ts

@@ -0,0 +1,35 @@
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { SxClass } from "./SxClass"
+
+export abstract class SxPrimitiveBoolean extends SxClass {
+  value: boolean
+
+  constructor(v: boolean) {
+    super()
+    this.value = v
+  }
+
+  set(value: boolean) {
+    this.value = value
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SxPrimitiveBoolean {
+    const [rawVal] = primitiveSexprs
+    let booleanVal: boolean
+    if (typeof rawVal === "boolean") {
+      booleanVal = rawVal
+    } else if (typeof rawVal === "string") {
+      booleanVal = rawVal === "true" || rawVal === "yes"
+    } else {
+      booleanVal = false
+    }
+    // @ts-ignore
+    return new this(booleanVal)
+  }
+
+  override getString() {
+    return `(${this.token} ${this.value ? "yes" : "no"})`
+  }
+}

package/lib/sexpr/base-classes/SxPrimitiveNumber.ts

@@ -0,0 +1,26 @@
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { SxClass } from "./SxClass"
+
+export abstract class SxPrimitiveNumber extends SxClass {
+  value: number
+
+  constructor(v: number) {
+    super()
+    this.value = v
+  }
+
+  set(value: number) {
+    this.value = value
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SxPrimitiveNumber {
+    // @ts-ignore
+    return new this(primitiveSexprs[0] as number)
+  }
+
+  override getString() {
+    return `(${this.token} ${this.value})`
+  }
+}

package/lib/sexpr/base-classes/SxPrimitiveString.ts

@@ -0,0 +1,26 @@
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { SxClass } from "./SxClass"
+
+export abstract class SxPrimitiveString extends SxClass {
+  value: string
+
+  constructor(v: string) {
+    super()
+    this.value = v
+  }
+
+  set(value: string) {
+    this.value = value
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SxPrimitiveString {
+    // @ts-ignore
+    return new this(primitiveSexprs[0] as string)
+  }
+
+  override getString() {
+    return `(${this.token} ${this.value})`
+  }
+}

package/lib/sexpr/classes/At.ts

@@ -0,0 +1,38 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+
+export class At extends SxClass {
+  static override token = "at"
+  token = "at"
+
+  constructor(
+    args: [x: number, y: number, angle?: number],
+    opts: { isTextSymbol?: boolean } = {},
+  ) {
+    super()
+    this.x = args[0]
+    this.y = args[1]
+    this.angle = args[2]
+    if (this.angle && opts.isTextSymbol) {
+      this.angle *= 10
+    }
+  }
+
+  x: number
+  y: number
+  angle?: number
+
+  static override fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): At {
+    const [x, y, angle] = primitiveSexprs
+    return new At([x as number, y as number, angle as number])
+  }
+
+  override getString(): string {
+    const parts: Array<string | number> = [this.x, this.y]
+    if (this.angle !== undefined) {
+      parts.push(this.angle)
+    }
+    return `(at ${parts.join(" ")})`
+  }
+}
+SxClass.register(At)

package/lib/sexpr/classes/Bus.ts

@@ -0,0 +1,83 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { Pts } from "./Pts"
+import { Stroke } from "./Stroke"
+import { Uuid } from "./Uuid"
+
+const SUPPORTED_TOKENS = new Set(["pts", "stroke", "uuid"])
+
+export class Bus extends SxClass {
+  static override token = "bus"
+  static override parentToken = "kicad_sch"
+  override token = "bus"
+
+  private _sxPts?: Pts
+  private _sxStroke?: Stroke
+  private _sxUuid?: Uuid
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Bus {
+    const bus = new Bus()
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
+
+    if (Object.keys(arrayPropertyMap).length > 0) {
+      const tokens = Object.keys(arrayPropertyMap).join(", ")
+      throw new Error(`bus 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 bus expression: ${unsupportedTokens.join(", ")}`,
+      )
+    }
+
+    bus._sxPts = propertyMap.pts as Pts | undefined
+    bus._sxStroke = propertyMap.stroke as Stroke | undefined
+    bus._sxUuid = propertyMap.uuid as Uuid | undefined
+
+    return bus
+  }
+
+  get points(): Pts | undefined {
+    return this._sxPts
+  }
+
+  set points(value: Pts | undefined) {
+    this._sxPts = value
+  }
+
+  get stroke(): Stroke | undefined {
+    return this._sxStroke
+  }
+
+  set stroke(value: Stroke | undefined) {
+    this._sxStroke = 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._sxPts) children.push(this._sxPts)
+    if (this._sxStroke) children.push(this._sxStroke)
+    if (this._sxUuid) children.push(this._sxUuid)
+    return children
+  }
+}
+SxClass.register(Bus)

package/lib/sexpr/classes/BusEntry.ts

@@ -0,0 +1,142 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { At } from "./At"
+import { Stroke } from "./Stroke"
+import { Uuid } from "./Uuid"
+
+const SUPPORTED_TOKENS = new Set(["at", "size", "stroke", "uuid"])
+
+export class BusEntry extends SxClass {
+  static override token = "bus_entry"
+  static override parentToken = "kicad_sch"
+  override token = "bus_entry"
+
+  private _sxAt?: At
+  private _sxSize?: BusEntrySize
+  private _sxStroke?: Stroke
+  private _sxUuid?: Uuid
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): BusEntry {
+    const entry = new BusEntry()
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
+
+    if (Object.keys(arrayPropertyMap).length > 0) {
+      const tokens = Object.keys(arrayPropertyMap).join(", ")
+      throw new Error(
+        `bus_entry 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 bus_entry expression: ${unsupportedTokens.join(", ")}`,
+      )
+    }
+
+    entry._sxAt = propertyMap.at as At | undefined
+    entry._sxSize = propertyMap.size as BusEntrySize | undefined
+    entry._sxStroke = propertyMap.stroke as Stroke | undefined
+    entry._sxUuid = propertyMap.uuid as Uuid | undefined
+
+    return entry
+  }
+
+  get at(): At | undefined {
+    return this._sxAt
+  }
+
+  set at(value: At | undefined) {
+    this._sxAt = value
+  }
+
+  get size(): { x: number; y: number } | undefined {
+    return this._sxSize?.toObject()
+  }
+
+  set size(value: BusEntrySize | { x: number; y: number } | undefined) {
+    if (value === undefined) {
+      this._sxSize = undefined
+      return
+    }
+    if (value instanceof BusEntrySize) {
+      this._sxSize = value
+      return
+    }
+    this._sxSize = new BusEntrySize(value.x, value.y)
+  }
+
+  get stroke(): Stroke | undefined {
+    return this._sxStroke
+  }
+
+  set stroke(value: Stroke | undefined) {
+    this._sxStroke = 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._sxSize) children.push(this._sxSize)
+    if (this._sxStroke) children.push(this._sxStroke)
+    if (this._sxUuid) children.push(this._sxUuid)
+    return children
+  }
+}
+SxClass.register(BusEntry)
+
+export class BusEntrySize extends SxClass {
+  static override token = "size"
+  static override parentToken = "bus_entry"
+  override token = "size"
+
+  private _x: number
+  private _y: number
+
+  constructor(x: number, y: number) {
+    super()
+    this._x = x
+    this._y = y
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): BusEntrySize {
+    const [rawX, rawY] = primitiveSexprs
+    if (typeof rawX !== "number" || typeof rawY !== "number") {
+      throw new Error("bus_entry size expects two numeric arguments")
+    }
+    return new BusEntrySize(rawX, rawY)
+  }
+
+  toObject(): { x: number; y: number } {
+    return { x: this._x, y: this._y }
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(size ${this._x} ${this._y})`
+  }
+}
+SxClass.register(BusEntrySize)

package/lib/sexpr/classes/Color.ts

@@ -0,0 +1,29 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+
+export type RGBAColor = { r: number; g: number; b: number; a: number }
+
+export class Color extends SxClass {
+  static override token = "color"
+  token = "color"
+
+  color: RGBAColor
+
+  constructor(args: [r: number, g: number, b: number, a: number]) {
+    super()
+    this.color = { r: args[0], g: args[1], b: args[2], a: args[3] }
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Color {
+    return new Color(
+      primitiveSexprs as [r: number, g: number, b: number, a: number],
+    )
+  }
+
+  override getString() {
+    return `(color ${this.color.r} ${this.color.g} ${this.color.b} ${this.color.a})`
+  }
+}
+SxClass.register(Color)

package/lib/sexpr/classes/Dnp.ts

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

package/lib/sexpr/classes/EmbeddedFonts.ts

@@ -0,0 +1,70 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+
+export class EmbeddedFonts extends SxClass {
+  static override token = "embedded_fonts"
+  override token = "embedded_fonts"
+
+  private _enabled = false
+
+  constructor(enabled = false) {
+    super()
+    this._enabled = enabled
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): EmbeddedFonts {
+    if (primitiveSexprs.length === 0) {
+      return new EmbeddedFonts(false)
+    }
+
+    if (primitiveSexprs.length > 1) {
+      throw new Error("embedded_fonts accepts at most a single value")
+    }
+
+    const [raw] = primitiveSexprs
+
+    if (raw === undefined) {
+      return new EmbeddedFonts(false)
+    }
+
+    if (typeof raw === "boolean") {
+      return new EmbeddedFonts(raw)
+    }
+
+    if (typeof raw === "string") {
+      const normalized = raw.toLowerCase()
+      if (normalized === "yes") {
+        return new EmbeddedFonts(true)
+      }
+      if (normalized === "no") {
+        return new EmbeddedFonts(false)
+      }
+      throw new Error(
+        `embedded_fonts expects "yes" or "no", received "${raw}"`,
+      )
+    }
+
+    throw new Error(
+      `embedded_fonts encountered unsupported value ${JSON.stringify(raw)}`,
+    )
+  }
+
+  get enabled(): boolean {
+    return this._enabled
+  }
+
+  set enabled(value: boolean) {
+    this._enabled = value
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(embedded_fonts ${this._enabled ? "yes" : "no"})`
+  }
+}
+SxClass.register(EmbeddedFonts)

package/lib/sexpr/classes/ExcludeFromSim.ts

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

package/lib/sexpr/classes/FieldsAutoplaced.ts

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