kicadts 0.0.1

package/lib/sexpr/classes/TitleBlock.ts

@@ -0,0 +1,352 @@
+import { SxClass } from "../base-classes/SxClass"
+import { printSExpr, type PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { toNumberValue } from "../utils/toNumberValue"
+import { toStringValue } from "../utils/toStringValue"
+import { At } from "./At"
+import { TextEffects } from "./TextEffects"
+import { Uuid } from "./Uuid"
+
+function primitiveToString(value: PrimitiveSExpr | undefined): string {
+  if (value === undefined) return ""
+  const str = toStringValue(value)
+  if (str !== undefined) return str
+  return printSExpr(value)
+}
+
+export class TitleBlock extends SxClass {
+  static override token = "title_block"
+  token = "title_block"
+
+  private _sxTitle?: TitleBlockTitle
+  private _sxDate?: TitleBlockDate
+  private _sxRev?: TitleBlockRevision
+  private _sxCompany?: TitleBlockCompany
+  comments: TitleBlockComment[] = []
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): TitleBlock {
+    const titleBlock = new TitleBlock()
+
+    for (const primitive of primitiveSexprs) {
+      if (!Array.isArray(primitive) || primitive.length === 0) {
+        throw new Error(
+          `Unexpected primitive inside title_block: ${printSExpr(primitive)}`,
+        )
+      }
+
+      const parsed = SxClass.parsePrimitiveSexpr(primitive, {
+        parentToken: this.token,
+      })
+
+      if (!(parsed instanceof SxClass)) {
+        throw new Error(
+          `Unable to parse child node inside title_block: ${printSExpr(primitive)}`,
+        )
+      }
+
+      if (parsed instanceof TitleBlockTitle) {
+        titleBlock._sxTitle = parsed
+        continue
+      }
+      if (parsed instanceof TitleBlockDate) {
+        titleBlock._sxDate = parsed
+        continue
+      }
+      if (parsed instanceof TitleBlockRevision) {
+        titleBlock._sxRev = parsed
+        continue
+      }
+      if (parsed instanceof TitleBlockCompany) {
+        titleBlock._sxCompany = parsed
+        continue
+      }
+      if (parsed instanceof TitleBlockComment) {
+        titleBlock.comments.push(parsed)
+        continue
+      }
+
+      throw new Error(
+        `Unsupported child "${parsed.token}" inside title_block expression`,
+      )
+    }
+
+    return titleBlock
+  }
+
+  get title(): string | undefined {
+    return this._sxTitle?.value
+  }
+
+  set title(value: string | undefined) {
+    this._sxTitle = value === undefined ? undefined : new TitleBlockTitle(value)
+  }
+
+  get date(): string | undefined {
+    return this._sxDate?.value
+  }
+
+  set date(value: string | undefined) {
+    this._sxDate = value === undefined ? undefined : new TitleBlockDate(value)
+  }
+
+  get rev(): string | undefined {
+    return this._sxRev?.value
+  }
+
+  set rev(value: string | undefined) {
+    this._sxRev = value === undefined ? undefined : new TitleBlockRevision(value)
+  }
+
+  get company(): string | undefined {
+    return this._sxCompany?.value
+  }
+
+  set company(value: string | undefined) {
+    this._sxCompany =
+      value === undefined ? undefined : new TitleBlockCompany(value)
+  }
+
+  getComment(index: number): string | undefined {
+    return this.comments.find((comment) => comment.index === index)?.value
+  }
+
+  setComment(index: number, value: string) {
+    const existing = this.comments.find((comment) => comment.index === index)
+    if (existing) {
+      existing.value = value
+      return
+    }
+    this.comments.push(new TitleBlockComment(index, value))
+  }
+
+  removeComment(index: number) {
+    this.comments = this.comments.filter((comment) => comment.index !== index)
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxTitle) children.push(this._sxTitle)
+    if (this._sxDate) children.push(this._sxDate)
+    if (this._sxRev) children.push(this._sxRev)
+    if (this._sxCompany) children.push(this._sxCompany)
+
+    const sortedComments = [...this.comments].sort(
+      (a, b) => a.index - b.index,
+    )
+    children.push(...sortedComments)
+    return children
+  }
+
+  override getString(): string {
+    const lines: string[] = ["(title_block"]
+
+    for (const child of this.getChildren()) {
+      lines.push(child.getStringIndented())
+    }
+
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(TitleBlock)
+
+abstract class TitleBlockStringValue extends SxClass {
+  value: string
+
+  constructor(value: string) {
+    super()
+    this.value = value
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+}
+
+export class TitleBlockTitle extends TitleBlockStringValue {
+  static override token = "title"
+  static override parentToken = "title_block"
+  token = "title"
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): TitleBlockTitle {
+    const [rawValue] = primitiveSexprs
+    return new TitleBlockTitle(primitiveToString(rawValue))
+  }
+
+  override getString(): string {
+    return `(title ${quoteSExprString(this.value)})`
+  }
+}
+SxClass.register(TitleBlockTitle)
+
+export class TitleBlockDate extends TitleBlockStringValue {
+  static override token = "date"
+  static override parentToken = "title_block"
+  token = "date"
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): TitleBlockDate {
+    const [rawValue] = primitiveSexprs
+    return new TitleBlockDate(primitiveToString(rawValue))
+  }
+
+  override getString(): string {
+    return `(date ${quoteSExprString(this.value)})`
+  }
+}
+SxClass.register(TitleBlockDate)
+
+export class TitleBlockRevision extends TitleBlockStringValue {
+  static override token = "rev"
+  static override parentToken = "title_block"
+  token = "rev"
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): TitleBlockRevision {
+    const [rawValue] = primitiveSexprs
+    return new TitleBlockRevision(primitiveToString(rawValue))
+  }
+
+  override getString(): string {
+    return `(rev ${quoteSExprString(this.value)})`
+  }
+}
+SxClass.register(TitleBlockRevision)
+
+export class TitleBlockCompany extends TitleBlockStringValue {
+  static override token = "company"
+  static override parentToken = "title_block"
+  token = "company"
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): TitleBlockCompany {
+    const [rawValue] = primitiveSexprs
+    return new TitleBlockCompany(primitiveToString(rawValue))
+  }
+
+  override getString(): string {
+    return `(company ${quoteSExprString(this.value)})`
+  }
+}
+SxClass.register(TitleBlockCompany)
+
+export class TitleBlockComment extends SxClass {
+  static override token = "comment"
+  static override parentToken = "title_block"
+  token = "comment"
+
+  index: number
+  value: string
+  private _sxAt?: At
+  private _sxEffects?: TextEffects
+  private _sxUuid?: Uuid
+
+  constructor(index: number, value: string) {
+    super()
+    this.index = index
+    this.value = value
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): TitleBlockComment {
+    const [rawIndex, rawValue, ...rest] = primitiveSexprs
+    const index = toNumberValue(rawIndex)
+    if (index === undefined) {
+      throw new Error("title_block comment requires a numeric index")
+    }
+    const value = primitiveToString(rawValue)
+    const comment = new TitleBlockComment(index, value)
+
+    for (const primitive of rest) {
+      if (!Array.isArray(primitive) || primitive.length === 0) {
+        throw new Error(
+          `Unexpected primitive inside title_block comment: ${printSExpr(primitive)}`,
+        )
+      }
+
+      const parsed = SxClass.parsePrimitiveSexpr(primitive, {
+        parentToken: this.token,
+      })
+
+      if (!(parsed instanceof SxClass)) {
+        throw new Error(
+          `Unable to parse child node inside title_block comment: ${printSExpr(primitive)}`,
+        )
+      }
+
+      if (parsed instanceof At) {
+        comment._sxAt = parsed
+        continue
+      }
+      if (parsed instanceof TextEffects) {
+        comment._sxEffects = parsed
+        continue
+      }
+      if (parsed instanceof Uuid) {
+        comment._sxUuid = parsed
+        continue
+      }
+
+      throw new Error(
+        `Unsupported child "${parsed.token}" inside title_block comment`,
+      )
+    }
+
+    return comment
+  }
+
+  get at(): At | undefined {
+    return this._sxAt
+  }
+
+  set at(value: At | undefined) {
+    this._sxAt = value
+  }
+
+  get effects(): TextEffects | undefined {
+    return this._sxEffects
+  }
+
+  set effects(value: TextEffects | undefined) {
+    this._sxEffects = value
+  }
+
+  get uuid(): Uuid | undefined {
+    return this._sxUuid
+  }
+
+  set uuid(value: Uuid | undefined) {
+    this._sxUuid = value
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxAt) children.push(this._sxAt)
+    if (this._sxEffects) children.push(this._sxEffects)
+    if (this._sxUuid) children.push(this._sxUuid)
+    return children
+  }
+
+  override getString(): string {
+    const children = this.getChildren()
+    if (children.length === 0) {
+      return `(comment ${this.index} ${quoteSExprString(this.value)})`
+    }
+
+    const lines = [`(comment ${this.index} ${quoteSExprString(this.value)}`]
+    for (const child of children) {
+      lines.push(child.getStringIndented())
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(TitleBlockComment)

package/lib/sexpr/classes/Unit.ts

@@ -0,0 +1,28 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+
+export type UnitString = "inches" | "mils" | "millimeters" | "automatic"
+
+const unitValues = ["inches", "mils", "millimeters", "automatic"] as const
+
+export class Unit extends SxClass {
+  static override token = "unit"
+  token = "unit"
+
+  value: UnitString
+
+  constructor(value: UnitString | number) {
+    super()
+    if (typeof value === "number") {
+      this.value = unitValues[value]!
+    } else {
+      this.value = value
+    }
+  }
+
+  static override fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Unit {
+    const [numericValue] = primitiveSexprs
+    return new Unit(numericValue as number)
+  }
+}
+SxClass.register(Unit)

package/lib/sexpr/classes/Uuid.ts

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

package/lib/sexpr/classes/Via.ts

@@ -0,0 +1,328 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { At } from "./At"
+import { Layers } from "./Layers"
+import { Uuid } from "./Uuid"
+import { ViaNet } from "./ViaNet"
+import { toNumberValue } from "../utils/toNumberValue"
+import { toStringValue } from "../utils/toStringValue"
+import { PadTeardrops } from "./PadTeardrops"
+
+const BARE_FLAGS = new Set([
+  "locked",
+  "free",
+  "remove_unused_layers",
+  "keep_end_layers",
+])
+
+export class Via extends SxClass {
+  static override token = "via"
+  token = "via"
+
+  private _type?: string
+  private _locked = false
+  private _free = false
+  private _removeUnusedLayers = false
+  private _keepEndLayers = false
+  private _sxAt?: At
+  private _size?: number
+  private _drill?: number
+  private _sxLayers?: Layers
+  private _sxNet?: ViaNet
+  private _sxUuid?: Uuid
+  private _tstamp?: string
+  private _sxTeardrops?: PadTeardrops
+
+  static override fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Via {
+    const via = new Via()
+
+    for (const primitive of primitiveSexprs) {
+      if (typeof primitive === "string") {
+        via.consumeBareToken(primitive)
+        continue
+      }
+
+      if (!Array.isArray(primitive) || primitive.length === 0) {
+        throw new Error(
+          `via encountered unsupported primitive child: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      const [token, ...rest] = primitive
+      if (typeof token !== "string") {
+        throw new Error(
+          `via encountered child with non-string token: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      via.consumeNode(token, rest as PrimitiveSExpr[])
+    }
+
+    return via
+  }
+
+  private consumeBareToken(token: string) {
+    if (token === "blind" || token === "micro") {
+      this._type = token
+      return
+    }
+    if (!BARE_FLAGS.has(token)) {
+      throw new Error(`via encountered unsupported flag "${token}"`)
+    }
+    switch (token) {
+      case "locked":
+        this._locked = true
+        break
+      case "free":
+        this._free = true
+        break
+      case "remove_unused_layers":
+        this._removeUnusedLayers = true
+        break
+      case "keep_end_layers":
+        this._keepEndLayers = true
+        break
+    }
+  }
+
+  private consumeNode(token: string, args: PrimitiveSExpr[]) {
+    switch (token) {
+      case "type": {
+        const value = toStringValue(args[0])
+        if (value === undefined) {
+          throw new Error("via type expects a string value")
+        }
+        this._type = value
+        return
+      }
+      case "locked":
+        this._locked = this.parseYesNo(args)
+        return
+      case "free":
+        this._free = this.parseYesNo(args)
+        return
+      case "remove_unused_layers":
+        this._removeUnusedLayers = this.parseYesNo(args)
+        return
+      case "keep_end_layers":
+        this._keepEndLayers = this.parseYesNo(args)
+        return
+      case "at": {
+        const parsed = SxClass.parsePrimitiveSexpr(["at", ...args] as any, {
+          parentToken: this.token,
+        })
+        if (!(parsed instanceof At)) {
+          throw new Error("via failed to parse at child")
+        }
+        this._sxAt = parsed
+        return
+      }
+      case "size": {
+        const value = toNumberValue(args[0])
+        if (value === undefined) {
+          throw new Error("via size expects a numeric value")
+        }
+        this._size = value
+        return
+      }
+      case "drill": {
+        const value = toNumberValue(args[0])
+        if (value === undefined) {
+          throw new Error("via drill expects a numeric value")
+        }
+        this._drill = value
+        return
+      }
+      case "layers": {
+        this._sxLayers = Layers.fromSexprPrimitives(args)
+        return
+      }
+      case "net": {
+        this._sxNet = ViaNet.fromSexprPrimitives(args)
+        return
+      }
+      case "teardrops": {
+        this._sxTeardrops = PadTeardrops.fromSexprPrimitives(args)
+        return
+      }
+      case "uuid": {
+        const value = toStringValue(args[0])
+        if (value === undefined) {
+          throw new Error("via uuid expects a string value")
+        }
+        this._sxUuid = new Uuid(value)
+        return
+      }
+      case "tstamp": {
+        const value = toStringValue(args[0])
+        if (value === undefined) {
+          throw new Error("via tstamp expects a string value")
+        }
+        this._tstamp = value
+        return
+      }
+      default:
+        throw new Error(`via encountered unsupported child token "${token}"`)
+    }
+  }
+
+  private parseYesNo(args: PrimitiveSExpr[]): boolean {
+    if (args.length === 0) return true
+    const value = toStringValue(args[0])
+    if (value === undefined) {
+      throw new Error("Expected string when parsing via boolean child")
+    }
+    return /^(yes|true)$/iu.test(value)
+  }
+
+  get type(): string | undefined {
+    return this._type
+  }
+
+  set type(value: string | undefined) {
+    this._type = value
+  }
+
+  get locked(): boolean {
+    return this._locked
+  }
+
+  set locked(value: boolean) {
+    this._locked = value
+  }
+
+  get free(): boolean {
+    return this._free
+  }
+
+  set free(value: boolean) {
+    this._free = value
+  }
+
+  get removeUnusedLayers(): boolean {
+    return this._removeUnusedLayers
+  }
+
+  set removeUnusedLayers(value: boolean) {
+    this._removeUnusedLayers = value
+  }
+
+  get keepEndLayers(): boolean {
+    return this._keepEndLayers
+  }
+
+  set keepEndLayers(value: boolean) {
+    this._keepEndLayers = value
+  }
+
+  get at(): At | undefined {
+    return this._sxAt
+  }
+
+  set at(value: At | undefined) {
+    this._sxAt = value
+  }
+
+  get size(): number | undefined {
+    return this._size
+  }
+
+  set size(value: number | undefined) {
+    this._size = value
+  }
+
+  get drill(): number | undefined {
+    return this._drill
+  }
+
+  set drill(value: number | undefined) {
+    this._drill = value
+  }
+
+  get layers(): Layers | undefined {
+    return this._sxLayers
+  }
+
+  set layers(value: Layers | string[] | undefined) {
+    if (value === undefined) {
+      this._sxLayers = undefined
+      return
+    }
+    this._sxLayers = value instanceof Layers ? value : new Layers(value)
+  }
+
+  get net(): ViaNet | undefined {
+    return this._sxNet
+  }
+
+  set net(value: ViaNet | undefined) {
+    this._sxNet = 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)
+  }
+
+  get teardrops(): PadTeardrops | undefined {
+    return this._sxTeardrops
+  }
+
+  set teardrops(value: PadTeardrops | undefined) {
+    this._sxTeardrops = value
+  }
+
+  get tstamp(): string | undefined {
+    return this._tstamp
+  }
+
+  set tstamp(value: string | undefined) {
+    this._tstamp = value
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxAt) children.push(this._sxAt)
+    if (this._sxLayers) children.push(this._sxLayers)
+    if (this._sxNet) children.push(this._sxNet)
+    if (this._sxUuid) children.push(this._sxUuid)
+    if (this._sxTeardrops) children.push(this._sxTeardrops)
+    return children
+  }
+
+  override getString(): string {
+    const lines = ["(via"]
+
+    if (this._type !== undefined) {
+      lines.push(`  (type ${this._type})`)
+    }
+    if (this._locked) lines.push("  locked")
+    if (this._free) lines.push("  free")
+    if (this._removeUnusedLayers) lines.push("  remove_unused_layers")
+    if (this._keepEndLayers) lines.push("  keep_end_layers")
+    if (this._sxAt) lines.push(this._sxAt.getStringIndented())
+    if (this._size !== undefined) lines.push(`  (size ${this._size})`)
+    if (this._drill !== undefined) lines.push(`  (drill ${this._drill})`)
+    if (this._sxLayers) lines.push(this._sxLayers.getStringIndented())
+    if (this._sxNet) lines.push(this._sxNet.getStringIndented())
+    if (this._sxUuid) lines.push(this._sxUuid.getStringIndented())
+    if (this._tstamp !== undefined) {
+      lines.push(`  (tstamp ${quoteSExprString(this._tstamp)})`)
+    }
+    if (this._sxTeardrops) {
+      lines.push(this._sxTeardrops.getStringIndented())
+    }
+
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(Via)