kicadts 0.0.1

package/lib/sexpr/classes/KicadSch.ts

@@ -0,0 +1,303 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { Image } from "./Image"
+import { KicadSchGenerator } from "./KicadSchGenerator"
+import { KicadSchGeneratorVersion } from "./KicadSchGeneratorVersion"
+import { KicadSchVersion } from "./KicadSchVersion"
+import { LibSymbols } from "./LibSymbols"
+import { Paper } from "./Paper"
+import { Property } from "./Property"
+import { Label } from "./Label"
+import { SchematicSymbol } from "./Symbol"
+import { SchematicText } from "./SchematicText"
+import { Sheet } from "./Sheet"
+import { EmbeddedFonts } from "./EmbeddedFonts"
+import { SheetInstances } from "./SheetInstances"
+import { TitleBlock } from "./TitleBlock"
+import { Uuid } from "./Uuid"
+import { Wire } from "./Wire"
+import { Junction } from "./Junction"
+
+const SINGLE_CHILD_TOKENS = new Set([
+  "version",
+  "generator",
+  "generator_version",
+  "uuid",
+  "paper",
+  "title_block",
+  "lib_symbols",
+  "sheet_instances",
+  "embedded_fonts",
+])
+
+const MULTI_CHILD_TOKENS = new Set([
+  "property",
+  "image",
+  "sheet",
+  "symbol",
+  "text",
+  "label",
+  "junction",
+  "wire",
+])
+
+const SUPPORTED_CHILD_TOKENS = new Set([
+  ...SINGLE_CHILD_TOKENS,
+  ...MULTI_CHILD_TOKENS,
+])
+
+export class KicadSch extends SxClass {
+  static override token = "kicad_sch"
+  token = "kicad_sch"
+
+  private _sxVersion?: KicadSchVersion
+  private _sxGenerator?: KicadSchGenerator
+  private _sxGeneratorVersion?: KicadSchGeneratorVersion
+  private _sxUuid?: Uuid
+  private _sxPaper?: Paper
+  private _sxTitleBlock?: TitleBlock
+  private _sxLibSymbols?: LibSymbols
+  private _sxSheetInstances?: SheetInstances
+  private _sxEmbeddedFonts?: EmbeddedFonts
+  private _properties: Property[] = []
+  private _images: Image[] = []
+  private _sheets: Sheet[] = []
+  private _symbols: SchematicSymbol[] = []
+  private _texts: SchematicText[] = []
+  private _labels: Label[] = []
+  private _wires: Wire[] = []
+  private _junctions: Junction[] = []
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): KicadSch {
+    const kicadSch = new KicadSch()
+
+    for (const primitive of primitiveSexprs) {
+      if (!Array.isArray(primitive)) {
+        throw new Error(
+          `kicad_sch encountered unexpected primitive child: ${JSON.stringify(primitive)}`,
+        )
+      }
+      if (primitive.length === 0 || typeof primitive[0] !== "string") {
+        throw new Error(
+          `kicad_sch encountered invalid child expression: ${JSON.stringify(primitive)}`,
+        )
+      }
+    }
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
+
+    for (const token of Object.keys(propertyMap)) {
+      if (!SUPPORTED_CHILD_TOKENS.has(token)) {
+        throw new Error(
+          `kicad_sch encountered unsupported child token "${token}"`,
+        )
+      }
+    }
+
+    for (const [token, entries] of Object.entries(arrayPropertyMap)) {
+      if (!SUPPORTED_CHILD_TOKENS.has(token)) {
+        throw new Error(
+          `kicad_sch encountered unsupported child token "${token}"`,
+        )
+      }
+      if (!MULTI_CHILD_TOKENS.has(token) && entries.length > 1) {
+        throw new Error(
+          `kicad_sch does not support repeated child token "${token}"`,
+        )
+      }
+    }
+
+    kicadSch._sxVersion = propertyMap.version as KicadSchVersion | undefined
+    kicadSch._sxGenerator = propertyMap.generator as
+      | KicadSchGenerator
+      | undefined
+    kicadSch._sxGeneratorVersion = propertyMap.generator_version as
+      | KicadSchGeneratorVersion
+      | undefined
+    kicadSch._sxUuid = propertyMap.uuid as Uuid | undefined
+    kicadSch._sxPaper = propertyMap.paper as Paper | undefined
+    kicadSch._sxTitleBlock = propertyMap.title_block as TitleBlock | undefined
+    kicadSch._sxLibSymbols = propertyMap.lib_symbols as LibSymbols | undefined
+    kicadSch._sxSheetInstances = propertyMap.sheet_instances as SheetInstances | undefined
+    kicadSch._sxEmbeddedFonts = propertyMap.embedded_fonts as EmbeddedFonts | undefined
+    kicadSch._properties = (arrayPropertyMap.property as Property[]) ?? []
+    kicadSch._images = (arrayPropertyMap.image as Image[]) ?? []
+    kicadSch._sheets = (arrayPropertyMap.sheet as Sheet[]) ?? []
+    kicadSch._symbols = (arrayPropertyMap.symbol as SchematicSymbol[]) ?? []
+    kicadSch._texts = (arrayPropertyMap.text as SchematicText[]) ?? []
+    kicadSch._labels = (arrayPropertyMap.label as Label[]) ?? []
+    kicadSch._junctions = (arrayPropertyMap.junction as Junction[]) ?? []
+    kicadSch._wires = (arrayPropertyMap.wire as Wire[]) ?? []
+
+    return kicadSch
+  }
+
+  get version(): number | undefined {
+    return this._sxVersion?.value
+  }
+
+  set version(value: number | undefined) {
+    this._sxVersion =
+      value === undefined ? undefined : new KicadSchVersion(value)
+  }
+
+  get generator(): string | undefined {
+    return this._sxGenerator?.value
+  }
+
+  set generator(value: string | undefined) {
+    this._sxGenerator =
+      value === undefined ? undefined : new KicadSchGenerator(value)
+  }
+
+  get generatorVersion(): string | undefined {
+    return this._sxGeneratorVersion?.value
+  }
+
+  set generatorVersion(value: string | undefined) {
+    this._sxGeneratorVersion =
+      value === undefined ? undefined : new KicadSchGeneratorVersion(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 paper(): Paper | undefined {
+    return this._sxPaper
+  }
+
+  set paper(value: Paper | undefined) {
+    this._sxPaper = value
+  }
+
+  get titleBlock(): TitleBlock | undefined {
+    return this._sxTitleBlock
+  }
+
+  set titleBlock(value: TitleBlock | undefined) {
+    this._sxTitleBlock = value
+  }
+
+  get libSymbols(): LibSymbols | undefined {
+    return this._sxLibSymbols
+  }
+
+  set libSymbols(value: LibSymbols | undefined) {
+    this._sxLibSymbols = value
+  }
+
+  get sheetInstances(): SheetInstances | undefined {
+    return this._sxSheetInstances
+  }
+
+  set sheetInstances(value: SheetInstances | undefined) {
+    this._sxSheetInstances = value
+  }
+
+  get embeddedFonts(): EmbeddedFonts | undefined {
+    return this._sxEmbeddedFonts
+  }
+
+  set embeddedFonts(value: EmbeddedFonts | undefined) {
+    this._sxEmbeddedFonts = value
+  }
+
+  get properties(): Property[] {
+    return [...this._properties]
+  }
+
+  set properties(value: Property[]) {
+    this._properties = [...value]
+  }
+
+  get images(): Image[] {
+    return [...this._images]
+  }
+
+  set images(value: Image[]) {
+    this._images = [...value]
+  }
+
+  get sheets(): Sheet[] {
+    return [...this._sheets]
+  }
+
+  set sheets(value: Sheet[]) {
+    this._sheets = [...value]
+  }
+
+  get symbols(): SchematicSymbol[] {
+    return [...this._symbols]
+  }
+
+  set symbols(value: SchematicSymbol[]) {
+    this._symbols = [...value]
+  }
+
+  get texts(): SchematicText[] {
+    return [...this._texts]
+  }
+
+  set texts(value: SchematicText[]) {
+    this._texts = [...value]
+  }
+
+  get labels(): Label[] {
+    return [...this._labels]
+  }
+
+  set labels(value: Label[]) {
+    this._labels = [...value]
+  }
+
+  get junctions(): Junction[] {
+    return [...this._junctions]
+  }
+
+  set junctions(value: Junction[]) {
+    this._junctions = [...value]
+  }
+
+  get wires(): Wire[] {
+    return [...this._wires]
+  }
+
+  set wires(value: Wire[]) {
+    this._wires = [...value]
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxVersion) children.push(this._sxVersion)
+    if (this._sxGenerator) children.push(this._sxGenerator)
+    if (this._sxGeneratorVersion) children.push(this._sxGeneratorVersion)
+    if (this._sxUuid) children.push(this._sxUuid)
+    if (this._sxPaper) children.push(this._sxPaper)
+    if (this._sxTitleBlock) children.push(this._sxTitleBlock)
+    if (this._sxLibSymbols) children.push(this._sxLibSymbols)
+    if (this._sxSheetInstances) children.push(this._sxSheetInstances)
+    if (this._sxEmbeddedFonts) children.push(this._sxEmbeddedFonts)
+    children.push(...this._properties)
+    children.push(...this._images)
+    children.push(...this._sheets)
+    children.push(...this._symbols)
+    children.push(...this._texts)
+    children.push(...this._labels)
+    children.push(...this._junctions)
+    children.push(...this._wires)
+    return children
+  }
+}
+SxClass.register(KicadSch)

package/lib/sexpr/classes/KicadSchGenerator.ts

@@ -0,0 +1,32 @@
+import { SxClass } from "../base-classes/SxClass"
+import { SxPrimitiveString } from "../base-classes/SxPrimitiveString"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { toStringValue } from "../utils/toStringValue"
+
+const isSymbolToken = (value: string) => /^[A-Za-z0-9._-]+$/.test(value)
+
+export class KicadSchGenerator extends SxPrimitiveString {
+  static override token = "generator"
+  static override parentToken = "kicad_sch"
+  override token = "generator"
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): KicadSchGenerator {
+    const [rawValue] = primitiveSexprs
+    const parsedValue = toStringValue(rawValue)
+    if (parsedValue === undefined) {
+      throw new Error("generator expects a string argument")
+    }
+    return new KicadSchGenerator(parsedValue)
+  }
+
+  override getString(): string {
+    const serialized = isSymbolToken(this.value)
+      ? this.value
+      : quoteSExprString(this.value)
+    return `(generator ${serialized})`
+  }
+}
+SxClass.register(KicadSchGenerator)

package/lib/sexpr/classes/KicadSchGeneratorVersion.ts

@@ -0,0 +1,30 @@
+import { SxClass } from "../base-classes/SxClass"
+import { SxPrimitiveString } from "../base-classes/SxPrimitiveString"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { toStringValue } from "../utils/toStringValue"
+
+export class KicadSchGeneratorVersion extends SxPrimitiveString {
+  static override token = "generator_version"
+  static override parentToken = "kicad_sch"
+  override token = "generator_version"
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): KicadSchGeneratorVersion {
+    const [rawValue] = primitiveSexprs
+    const parsedValue = toStringValue(rawValue)
+    if (parsedValue === undefined) {
+      throw new Error("generator_version expects a string argument")
+    }
+    return new KicadSchGeneratorVersion(parsedValue)
+  }
+
+  override getString(): string {
+    const serialized = /^[^\s()\"]+$/.test(this.value)
+      ? this.value
+      : quoteSExprString(this.value)
+    return `(generator_version ${serialized})`
+  }
+}
+SxClass.register(KicadSchGeneratorVersion)

package/lib/sexpr/classes/KicadSchVersion.ts

@@ -0,0 +1,22 @@
+import { SxClass } from "../base-classes/SxClass"
+import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { toNumberValue } from "../utils/toNumberValue"
+
+export class KicadSchVersion extends SxPrimitiveNumber {
+  static override token = "version"
+  static override parentToken = "kicad_sch"
+  override token = "version"
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): KicadSchVersion {
+    const [rawValue] = primitiveSexprs
+    const parsedValue = toNumberValue(rawValue)
+    if (parsedValue === undefined) {
+      throw new Error("version expects a numeric argument")
+    }
+    return new KicadSchVersion(parsedValue)
+  }
+}
+SxClass.register(KicadSchVersion)

package/lib/sexpr/classes/Label.ts

@@ -0,0 +1,136 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { toStringValue } from "../utils/toStringValue"
+import { At } from "./At"
+import { TextEffects } from "./TextEffects"
+import { Uuid } from "./Uuid"
+import { FieldsAutoplaced } from "./FieldsAutoplaced"
+
+const SUPPORTED_TOKENS = new Set(["at", "effects", "uuid", "fields_autoplaced"])
+
+export class Label extends SxClass {
+  static override token = "label"
+  static override parentToken = "kicad_sch"
+  override token = "label"
+
+  private _value = ""
+  private _sxAt?: At
+  private _sxEffects?: TextEffects
+  private _sxUuid?: Uuid
+  private _sxFieldsAutoplaced?: FieldsAutoplaced
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Label {
+    const [textPrimitive, ...rest] = primitiveSexprs
+    const value = toStringValue(textPrimitive)
+    if (value === undefined) {
+      throw new Error("label expects a string value")
+    }
+
+    const label = new Label()
+    label._value = value
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(rest, this.token)
+
+    const unsupportedTokens = Object.keys(propertyMap).filter(
+      (token) => !SUPPORTED_TOKENS.has(token),
+    )
+    if (unsupportedTokens.length > 0) {
+      throw new Error(
+        `Unsupported child tokens inside label expression: ${unsupportedTokens.join(", ")}`,
+      )
+    }
+
+    for (const [token, entries] of Object.entries(arrayPropertyMap)) {
+      if (!SUPPORTED_TOKENS.has(token)) {
+        throw new Error(
+          `Unsupported child tokens inside label expression: ${token}`,
+        )
+      }
+      if (entries.length > 1) {
+        throw new Error(`label does not support repeated child tokens: ${token}`)
+      }
+    }
+
+    label._sxAt =
+      (arrayPropertyMap.at?.[0] as At | undefined) ??
+      (propertyMap.at as At | undefined)
+    label._sxEffects =
+      (arrayPropertyMap.effects?.[0] as TextEffects | undefined) ??
+      (propertyMap.effects as TextEffects | undefined)
+    label._sxUuid =
+      (arrayPropertyMap.uuid?.[0] as Uuid | undefined) ??
+      (propertyMap.uuid as Uuid | undefined)
+    label._sxFieldsAutoplaced =
+      (arrayPropertyMap.fields_autoplaced?.[0] as FieldsAutoplaced | undefined) ??
+      (propertyMap.fields_autoplaced as FieldsAutoplaced | undefined)
+
+    return label
+  }
+
+  get value(): string {
+    return this._value
+  }
+
+  set value(newValue: string) {
+    this._value = newValue
+  }
+
+  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 | string | undefined) {
+    if (value === undefined) {
+      this._sxUuid = undefined
+      return
+    }
+    this._sxUuid = value instanceof Uuid ? value : new Uuid(value)
+  }
+
+  get fieldsAutoplaced(): boolean {
+    return this._sxFieldsAutoplaced?.value ?? false
+  }
+
+  set fieldsAutoplaced(value: boolean) {
+    this._sxFieldsAutoplaced = new FieldsAutoplaced(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)
+    if (this._sxFieldsAutoplaced) children.push(this._sxFieldsAutoplaced)
+    return children
+  }
+
+  override getString(): string {
+    const lines = [`(label ${quoteSExprString(this._value)}`]
+    for (const child of this.getChildren()) {
+      lines.push(child.getStringIndented())
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(Label)

package/lib/sexpr/classes/Layer.ts

@@ -0,0 +1,51 @@
+import { SxClass } from "../base-classes/SxClass"
+import { printSExpr, type PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { quoteSExprString } from "../utils/quoteSExprString"
+
+export class Layer extends SxClass {
+  static override token = "layer"
+  token = "layer"
+
+  private _names: string[] = []
+
+  constructor(names: Array<string | number> = []) {
+    super()
+    this.names = names.map((name) => String(name))
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Layer {
+    const names = primitiveSexprs.map((primitive) =>
+      typeof primitive === "string" || typeof primitive === "number"
+        ? String(primitive)
+        : printSExpr(primitive),
+    )
+    return new Layer(names)
+  }
+
+  get names(): string[] {
+    return [...this._names]
+  }
+
+  set names(values: Array<string | number>) {
+    this._names = values.map((value) => String(value))
+  }
+
+  addName(name: string | number) {
+    this._names.push(String(name))
+  }
+
+  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 `(layer ${rendered})`
+  }
+}
+SxClass.register(Layer)

package/lib/sexpr/classes/Layers.ts

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

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