kicadts 0.0.2 → 0.0.4

package/lib/sexpr/classes/Layers.ts

@@ -1,47 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import { printSExpr, type PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { quoteSExprString } from "../utils/quoteSExprString"
-
-export class Layers extends SxClass {
-  static override token = "layers"
-  token = "layers"
-
-  private _names: string[] = []
-
-  constructor(names: Array<string | number> = []) {
-    super()
-    this.names = names
-  }
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): Layers {
-    const names = primitiveSexprs.map((primitive) =>
-      typeof primitive === "string" || typeof primitive === "number"
-        ? String(primitive)
-        : printSExpr(primitive),
-    )
-    return new Layers(names)
-  }
-
-  get names(): string[] {
-    return [...this._names]
-  }
-
-  set names(values: Array<string | number>) {
-    this._names = values.map((value) => String(value))
-  }
-
-  override getString(): string {
-    const rendered = this._names
-      .map((name) => {
-        if (/^[^\s()"]+$/u.test(name) && !["nil", "#t", "#f"].includes(name)) {
-          return name
-        }
-        return quoteSExprString(name)
-      })
-      .join(" ")
-    return `(layers ${rendered})`
-  }
-}
-SxClass.register(Layers)

package/lib/sexpr/classes/LibSymbols.ts

@@ -1,61 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { SchematicSymbol } from "./Symbol"
-
-const SUPPORTED_ARRAY_TOKENS = new Set(["symbol"])
-
-export class LibSymbols extends SxClass {
-  static override token = "lib_symbols"
-  static override parentToken = "kicad_sch"
-  override token = "lib_symbols"
-
-  private _symbols: SchematicSymbol[] = []
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): LibSymbols {
-    const libSymbols = new LibSymbols()
-
-    const { propertyMap, arrayPropertyMap } =
-      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
-
-    const unsupportedSingularTokens = Object.keys(propertyMap).filter(
-      (token) => !SUPPORTED_ARRAY_TOKENS.has(token),
-    )
-    if (unsupportedSingularTokens.length > 0) {
-      throw new Error(
-        `Unsupported child tokens inside lib_symbols expression: ${unsupportedSingularTokens.join(", ")}`,
-      )
-    }
-
-    const unsupportedArrayTokens = Object.keys(arrayPropertyMap).filter(
-      (token) => !SUPPORTED_ARRAY_TOKENS.has(token),
-    )
-    if (unsupportedArrayTokens.length > 0) {
-      throw new Error(
-        `Unsupported repeated child tokens inside lib_symbols expression: ${unsupportedArrayTokens.join(", ")}`,
-      )
-    }
-
-    const symbols = (arrayPropertyMap.symbol as SchematicSymbol[]) ?? []
-    if (!symbols.length && propertyMap.symbol) {
-      symbols.push(propertyMap.symbol as SchematicSymbol)
-    }
-    libSymbols._symbols = symbols
-
-    return libSymbols
-  }
-
-  get symbols(): SchematicSymbol[] {
-    return [...this._symbols]
-  }
-
-  set symbols(value: SchematicSymbol[]) {
-    this._symbols = [...value]
-  }
-
-  override getChildren(): SxClass[] {
-    return [...this._symbols]
-  }
-}
-SxClass.register(LibSymbols)

package/lib/sexpr/classes/NoConnect.ts

@@ -1,90 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { At, type AtInput } from "./At"
-import { Uuid } from "./Uuid"
-
-const SUPPORTED_TOKENS = new Set(["at", "uuid"])
-
-export interface NoConnectConstructorParams {
-  at?: AtInput
-  uuid?: string | 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
-
-  constructor(params: NoConnectConstructorParams = {}) {
-    super()
-
-    if (params.at !== undefined) {
-      this.at = params.at
-    }
-
-    if (params.uuid !== undefined) {
-      this.uuid = params.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: AtInput | undefined) {
-    this._sxAt = value !== undefined ? At.from(value) : undefined
-  }
-
-  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

@@ -1,8 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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 type PadLayersInput = PadLayers | string[]
-
-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 from(input: PadLayersInput): PadLayers {
-    if (input instanceof PadLayers) {
-      return input
-    }
-    return new PadLayers(input)
-  }
-
-  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

@@ -1,56 +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 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)