kicadts 0.0.2 → 0.0.4

package/lib/sexpr/classes/Via.ts

@@ -1,363 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { quoteSExprString } from "../utils/quoteSExprString"
-import { At, type AtInput } 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 interface ViaConstructorParams {
-  type?: string
-  locked?: boolean
-  free?: boolean
-  removeUnusedLayers?: boolean
-  keepEndLayers?: boolean
-  at?: AtInput
-  size?: number
-  drill?: number
-  layers?: Layers | string[]
-  net?: ViaNet
-  uuid?: Uuid | string
-  tstamp?: string
-  teardrops?: PadTeardrops
-}
-
-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
-
-  constructor(params: ViaConstructorParams = {}) {
-    super()
-    if (params.type !== undefined) this.type = params.type
-    if (params.locked !== undefined) this.locked = params.locked
-    if (params.free !== undefined) this.free = params.free
-    if (params.removeUnusedLayers !== undefined)
-      this.removeUnusedLayers = params.removeUnusedLayers
-    if (params.keepEndLayers !== undefined)
-      this.keepEndLayers = params.keepEndLayers
-    if (params.at !== undefined) this.at = params.at
-    if (params.size !== undefined) this.size = params.size
-    if (params.drill !== undefined) this.drill = params.drill
-    if (params.layers !== undefined) this.layers = params.layers
-    if (params.net !== undefined) this.net = params.net
-    if (params.uuid !== undefined) this.uuid = params.uuid
-    if (params.tstamp !== undefined) this.tstamp = params.tstamp
-    if (params.teardrops !== undefined) this.teardrops = params.teardrops
-  }
-
-  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: AtInput | undefined) {
-    this._sxAt = value !== undefined ? At.from(value) : undefined
-  }
-
-  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)

package/lib/sexpr/classes/ViaNet.ts

@@ -1,60 +0,0 @@
-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 ViaNet extends SxClass {
-  static override token = "net"
-  static override parentToken = "via"
-  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[],
-  ): ViaNet {
-    const id = toNumberValue(primitiveSexprs[0])
-    if (id === undefined) {
-      throw new Error("via net requires a numeric id")
-    }
-    const name =
-      primitiveSexprs.length > 1 ? toStringValue(primitiveSexprs[1]) : undefined
-    return new ViaNet(id, name)
-  }
-
-  get id(): number {
-    return this._id
-  }
-
-  set id(value: number) {
-    this._id = value
-  }
-
-  get name(): string | undefined {
-    return this._name
-  }
-
-  set name(value: string | undefined) {
-    this._name = value
-  }
-
-  override getChildren(): SxClass[] {
-    return []
-  }
-
-  override getString(): string {
-    if (this._name !== undefined) {
-      return `(net ${this._id} ${quoteSExprString(this._name)})`
-    }
-    return `(net ${this._id})`
-  }
-}
-SxClass.register(ViaNet)

package/lib/sexpr/classes/Width.ts

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

package/lib/sexpr/classes/Wire.ts

@@ -1,111 +0,0 @@
-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 interface WireConstructorParams {
-  points?: Pts
-  stroke?: Stroke
-  uuid?: string | Uuid
-}
-
-export class Wire extends SxClass {
-  static override token = "wire"
-  static override parentToken = "kicad_sch"
-  override token = "wire"
-
-  private _sxPts?: Pts
-  private _sxStroke?: Stroke
-  private _sxUuid?: Uuid
-
-  constructor(params: WireConstructorParams = {}) {
-    super()
-
-    if (params.points !== undefined) {
-      this.points = params.points
-    }
-
-    if (params.stroke !== undefined) {
-      this.stroke = params.stroke
-    }
-
-    if (params.uuid !== undefined) {
-      this.uuid = params.uuid
-    }
-  }
-
-  static override fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Wire {
-    const wire = new Wire()
-
-    const { propertyMap, arrayPropertyMap } =
-      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
-
-    for (const [token, entries] of Object.entries(arrayPropertyMap)) {
-      if (!SUPPORTED_TOKENS.has(token)) {
-        throw new Error(
-          `Unsupported child tokens inside wire expression: ${token}`,
-        )
-      }
-      if (entries.length > 1) {
-        throw new Error(`wire does not support repeated child tokens: ${token}`)
-      }
-    }
-
-    const unsupportedTokens = Object.keys(propertyMap).filter(
-      (token) => !SUPPORTED_TOKENS.has(token),
-    )
-    if (unsupportedTokens.length > 0) {
-      throw new Error(
-        `Unsupported child tokens inside wire expression: ${unsupportedTokens.join(", ")}`,
-      )
-    }
-
-    wire._sxPts =
-      (arrayPropertyMap.pts?.[0] as Pts | undefined) ??
-      (propertyMap.pts as Pts | undefined)
-    wire._sxStroke = propertyMap.stroke as Stroke | undefined
-    wire._sxUuid = propertyMap.uuid as Uuid | undefined
-
-    return wire
-  }
-
-  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(Wire)

package/lib/sexpr/classes/Xy.ts

@@ -1,33 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { toNumberValue } from "../utils/toNumberValue"
-
-export class Xy extends SxClass {
-  static override token = "xy"
-  token = "xy"
-
-  x: number
-  y: number
-
-  constructor(x: number, y: number) {
-    super()
-    this.x = x
-    this.y = y
-  }
-
-  static override fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Xy {
-    const [rawX, rawY] = primitiveSexprs
-    const x = toNumberValue(rawX) ?? 0
-    const y = toNumberValue(rawY) ?? 0
-    return new Xy(x, y)
-  }
-
-  override getChildren(): SxClass[] {
-    return []
-  }
-
-  override getString(): string {
-    return `(xy ${this.x} ${this.y})`
-  }
-}
-SxClass.register(Xy)

package/lib/sexpr/classes/Zone.ts

@@ -1,39 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import { printSExpr, type PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-
-export class Zone extends SxClass {
-  static override token = "zone"
-  token = "zone"
-
-  private _rawChildren: PrimitiveSExpr[] = []
-
-  static override fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Zone {
-    const zone = new Zone()
-    zone._rawChildren = [...primitiveSexprs]
-    return zone
-  }
-
-  get rawChildren(): PrimitiveSExpr[] {
-    return [...this._rawChildren]
-  }
-
-  set rawChildren(children: PrimitiveSExpr[]) {
-    this._rawChildren = [...children]
-  }
-
-  override getChildren(): SxClass[] {
-    return []
-  }
-
-  override getString(): string {
-    const lines = ["(zone"]
-
-    for (const arg of this._rawChildren) {
-      lines.push(`  ${printSExpr(arg)}`)
-    }
-
-    lines.push(")")
-    return lines.join("\n")
-  }
-}
-SxClass.register(Zone)