kicadts 0.0.1

package/lib/sexpr/classes/Property.ts

@@ -0,0 +1,246 @@
+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"
+import { At } from "./At"
+import { Layer } from "./Layer"
+import { PropertyHide } from "./PropertyHide"
+import { PropertyUnlocked } from "./PropertyUnlocked"
+import { TextEffects } from "./TextEffects"
+import { Uuid } from "./Uuid"
+import { Xy } from "./Xy"
+
+const SUPPORTED_SINGLE_CHILDREN = new Set([
+  "at",
+  "xy",
+  "layer",
+  "uuid",
+  "effects",
+  "unlocked",
+  "hide",
+])
+
+const ensureSingleChild = (
+  arrayPropertyMap: Record<string, SxClass[]>,
+  token: string,
+) => {
+  const entries = arrayPropertyMap[token]
+  if (entries && entries.length > 1) {
+    throw new Error(`property does not support repeated "${token}" children`)
+  }
+}
+
+const primitiveToString = (value: PrimitiveSExpr | undefined): string | undefined => {
+  if (value === undefined) {
+    return undefined
+  }
+  const asString = toStringValue(value)
+  if (asString !== undefined) {
+    return asString
+  }
+  return printSExpr(value)
+}
+
+export class Property extends SxClass {
+  static override token = "property"
+  token = "property"
+
+  private _key = ""
+  private _value = ""
+  private _sxAt?: At
+  private _sxXy?: Xy
+  private _sxLayer?: Layer
+  private _sxUuid?: Uuid
+  private _sxEffects?: TextEffects
+  private _sxUnlocked?: PropertyUnlocked
+  private _sxHide?: PropertyHide
+
+  constructor(key = "", value = "") {
+    super()
+    this._key = key
+    this._value = value
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Property {
+    if (primitiveSexprs.length < 2) {
+      throw new Error("property requires key and value arguments")
+    }
+
+    const [rawKey, rawValue, ...rest] = primitiveSexprs
+
+    const key = primitiveToString(rawKey)
+    const value = primitiveToString(rawValue)
+    if (key === undefined) {
+      throw new Error("property key must be a printable value")
+    }
+    if (value === undefined) {
+      throw new Error("property value must be a printable value")
+    }
+
+    for (const primitive of rest) {
+      if (!Array.isArray(primitive)) {
+        throw new Error(
+          `property encountered unexpected primitive child: ${JSON.stringify(primitive)}`,
+        )
+      }
+      if (primitive.length === 0 || typeof primitive[0] !== "string") {
+        throw new Error(
+          `property encountered invalid child expression: ${JSON.stringify(primitive)}`,
+        )
+      }
+    }
+
+    const property = new Property(key, value)
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(rest, this.token)
+
+    for (const token of Object.keys(propertyMap)) {
+      if (!SUPPORTED_SINGLE_CHILDREN.has(token)) {
+        throw new Error(
+          `property encountered unsupported child token "${token}"`,
+        )
+      }
+    }
+
+    for (const token of Object.keys(arrayPropertyMap)) {
+      if (!SUPPORTED_SINGLE_CHILDREN.has(token)) {
+        throw new Error(
+          `property encountered unsupported child token "${token}"`,
+        )
+      }
+      ensureSingleChild(arrayPropertyMap, token)
+    }
+
+    const at = propertyMap.at as At | undefined
+    const xy = propertyMap.xy as Xy | undefined
+    if (at && xy) {
+      throw new Error("property can't include both at and xy children")
+    }
+
+    property._sxAt = at
+    property._sxXy = xy
+    property._sxLayer = propertyMap.layer as Layer | undefined
+    property._sxUuid = propertyMap.uuid as Uuid | undefined
+    property._sxEffects = propertyMap.effects as TextEffects | undefined
+    property._sxUnlocked = propertyMap.unlocked as PropertyUnlocked | undefined
+    property._sxHide = propertyMap.hide as PropertyHide | undefined
+
+    return property
+  }
+
+  get key(): string {
+    return this._key
+  }
+
+  set key(value: string) {
+    this._key = value
+  }
+
+  get value(): string {
+    return this._value
+  }
+
+  set value(value: string) {
+    this._value = value
+  }
+
+  get position(): At | Xy | undefined {
+    return this._sxAt ?? this._sxXy
+  }
+
+  set position(value: At | Xy | undefined) {
+    if (value instanceof At) {
+      this._sxAt = value
+      this._sxXy = undefined
+      return
+    }
+    if (value instanceof Xy) {
+      this._sxXy = value
+      this._sxAt = undefined
+      return
+    }
+    this._sxAt = undefined
+    this._sxXy = undefined
+  }
+
+  get layer(): Layer | undefined {
+    return this._sxLayer
+  }
+
+  set layer(value: Layer | Array<string | number> | string | undefined) {
+    if (value === undefined) {
+      this._sxLayer = undefined
+      return
+    }
+    if (value instanceof Layer) {
+      this._sxLayer = value
+      return
+    }
+    const names = Array.isArray(value) ? value : [value]
+    this._sxLayer = new Layer(names)
+  }
+
+  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 effects(): TextEffects | undefined {
+    return this._sxEffects
+  }
+
+  set effects(value: TextEffects | undefined) {
+    this._sxEffects = value
+  }
+
+  get unlocked(): boolean {
+    return this._sxUnlocked?.value ?? false
+  }
+
+  set unlocked(value: boolean) {
+    this._sxUnlocked = new PropertyUnlocked(value)
+  }
+
+  get hidden(): boolean {
+    return this._sxHide?.value ?? false
+  }
+
+  set hidden(value: boolean) {
+    this._sxHide = new PropertyHide(value)
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxAt) children.push(this._sxAt)
+    if (this._sxXy) children.push(this._sxXy)
+    if (this._sxUnlocked) children.push(this._sxUnlocked)
+    if (this._sxLayer) children.push(this._sxLayer)
+    if (this._sxHide) children.push(this._sxHide)
+    if (this._sxUuid) children.push(this._sxUuid)
+    if (this._sxEffects) children.push(this._sxEffects)
+    return children
+  }
+
+  override getString(): string {
+    const lines = [
+      `(property ${quoteSExprString(this._key)} ${quoteSExprString(this._value)}`,
+    ]
+    for (const child of this.getChildren()) {
+      lines.push(child.getStringIndented())
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(Property)

package/lib/sexpr/classes/PropertyHide.ts

@@ -0,0 +1,9 @@
+import { SxPrimitiveBoolean } from "../base-classes/SxPrimitiveBoolean"
+import { SxClass } from "../base-classes/SxClass"
+
+export class PropertyHide extends SxPrimitiveBoolean {
+  static override token = "hide"
+  static override parentToken = "property"
+  token = "hide"
+}
+SxClass.register(PropertyHide)

package/lib/sexpr/classes/PropertyUnlocked.ts

@@ -0,0 +1,9 @@
+import { SxPrimitiveBoolean } from "../base-classes/SxPrimitiveBoolean"
+import { SxClass } from "../base-classes/SxClass"
+
+export class PropertyUnlocked extends SxPrimitiveBoolean {
+  static override token = "unlocked"
+  static override parentToken = "property"
+  token = "unlocked"
+}
+SxClass.register(PropertyUnlocked)

package/lib/sexpr/classes/Pts.ts

@@ -0,0 +1,65 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { printSExpr } from "../parseToPrimitiveSExpr"
+import { Xy } from "./Xy"
+
+export class Pts extends SxClass {
+  static override token = "pts"
+  token = "pts"
+
+  points: Array<Xy>
+
+  constructor(points: Array<Xy> = []) {
+    super()
+    this.points = points
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Pts {
+    const points: Xy[] = []
+
+    for (const primitive of primitiveSexprs) {
+      if (!Array.isArray(primitive) || primitive.length === 0) {
+        throw new Error(`Unexpected primitive inside pts: ${printSExpr(primitive)}`)
+      }
+
+      const parsed = SxClass.parsePrimitiveSexpr(primitive, {
+        parentToken: this.token,
+      })
+
+      if (parsed instanceof Xy) {
+        points.push(parsed)
+        continue
+      }
+
+      if (parsed instanceof SxClass) {
+        throw new Error(
+          `Unsupported child "${parsed.token}" inside pts expression`,
+        )
+      }
+
+      throw new Error(`Unable to parse child inside pts: ${printSExpr(primitive)}`)
+    }
+
+    return new Pts(points)
+  }
+
+  override getChildren(): SxClass[] {
+    return [...this.points]
+  }
+
+  override getString(): string {
+    const lines = ["(pts"]
+    for (const point of this.points) {
+      const pointString = point.getString()
+      const segments = pointString.split("\n")
+      for (const segment of segments) {
+        lines.push(`  ${segment}`)
+      }
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(Pts)

package/lib/sexpr/classes/RenderCache.ts

@@ -0,0 +1,221 @@
+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"
+import { Pts } from "./Pts"
+
+type RenderCacheElement = RenderCachePolygon
+
+export class RenderCache extends SxClass {
+  static override token = "render_cache"
+  override token = "render_cache"
+
+  private _text: string
+  private _angle?: number
+  private _offsetX?: number
+  private _offsetY?: number
+  private _elements: RenderCacheElement[] = []
+
+  constructor(text = "") {
+    super()
+    this._text = text
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): RenderCache {
+    if (primitiveSexprs.length === 0) {
+      throw new Error("render_cache requires a text argument")
+    }
+
+    const [rawText, ...rest] = primitiveSexprs
+    const text = toStringValue(rawText)
+    if (text === undefined) {
+      throw new Error(
+        `render_cache text must be a string value, received ${JSON.stringify(rawText)}`,
+      )
+    }
+
+    const renderCache = new RenderCache(text)
+
+    const numericParams: number[] = []
+
+    for (const primitive of rest) {
+      if (Array.isArray(primitive)) {
+        const parsed = SxClass.parsePrimitiveSexpr(primitive, {
+          parentToken: this.token,
+        })
+        if (!(parsed instanceof SxClass)) {
+          throw new Error(
+            `render_cache child did not resolve to an SxClass: ${JSON.stringify(primitive)}`,
+          )
+        }
+
+        if (!(parsed instanceof RenderCachePolygon)) {
+          throw new Error(
+            `render_cache encountered unsupported child token "${parsed.token}"`,
+          )
+        }
+
+        renderCache._elements.push(parsed)
+        continue
+      }
+
+      const numeric = toNumberValue(primitive)
+      if (numeric === undefined) {
+        throw new Error(
+          `render_cache encountered non-numeric parameter ${JSON.stringify(primitive)}`,
+        )
+      }
+      numericParams.push(numeric)
+    }
+
+    if (numericParams.length > 0) {
+      renderCache._angle = numericParams[0]
+    }
+    if (numericParams.length > 1) {
+      renderCache._offsetX = numericParams[1]
+    }
+    if (numericParams.length > 2) {
+      renderCache._offsetY = numericParams[2]
+    }
+    if (numericParams.length > 3) {
+      throw new Error("render_cache supports at most three numeric parameters")
+    }
+
+    return renderCache
+  }
+
+  get text(): string {
+    return this._text
+  }
+
+  set text(value: string) {
+    this._text = value
+  }
+
+  get angle(): number | undefined {
+    return this._angle
+  }
+
+  set angle(value: number | undefined) {
+    this._angle = value
+  }
+
+  get offsetX(): number | undefined {
+    return this._offsetX
+  }
+
+  set offsetX(value: number | undefined) {
+    this._offsetX = value
+  }
+
+  get offsetY(): number | undefined {
+    return this._offsetY
+  }
+
+  set offsetY(value: number | undefined) {
+    this._offsetY = value
+  }
+
+  get elements(): RenderCacheElement[] {
+    return [...this._elements]
+  }
+
+  set elements(elements: RenderCacheElement[]) {
+    this._elements = [...elements]
+  }
+
+  addElement(element: RenderCacheElement) {
+    this._elements.push(element)
+  }
+
+  override getChildren(): SxClass[] {
+    return [...this._elements]
+  }
+
+  override getString(): string {
+    const headerParts: string[] = [quoteSExprString(this._text)]
+    if (this._angle !== undefined) {
+      headerParts.push(String(this._angle))
+    }
+    if (this._offsetX !== undefined) {
+      headerParts.push(String(this._offsetX))
+    }
+    if (this._offsetY !== undefined) {
+      headerParts.push(String(this._offsetY))
+    }
+
+    if (this._elements.length === 0) {
+      return `(render_cache ${headerParts.join(" ")})`
+    }
+
+    const lines = [`(render_cache ${headerParts.join(" ")}`]
+    for (const element of this._elements) {
+      lines.push(element.getStringIndented())
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(RenderCache)
+
+class RenderCachePolygon extends SxClass {
+  static override token = "polygon"
+  static override parentToken = "render_cache"
+  override token = "polygon"
+
+  private _contours: Pts[] = []
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): RenderCachePolygon {
+    const polygon = new RenderCachePolygon()
+
+    for (const primitive of primitiveSexprs) {
+      if (!Array.isArray(primitive) || primitive.length === 0) {
+        throw new Error(
+          `render_cache polygon encountered invalid child: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      const parsed = SxClass.parsePrimitiveSexpr(primitive, {
+        parentToken: this.token,
+      })
+
+      if (!(parsed instanceof SxClass)) {
+        throw new Error(
+          `render_cache polygon child did not resolve to an SxClass: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      if (!(parsed instanceof Pts)) {
+        throw new Error(
+          `render_cache polygon encountered unsupported token "${parsed.token}"`,
+        )
+      }
+
+      polygon._contours.push(parsed)
+    }
+
+    if (polygon._contours.length === 0) {
+      throw new Error("render_cache polygon requires at least one pts child")
+    }
+
+    return polygon
+  }
+
+  get contours(): Pts[] {
+    return [...this._contours]
+  }
+
+  set contours(value: Pts[]) {
+    this._contours = [...value]
+  }
+
+  override getChildren(): SxClass[] {
+    return [...this._contours]
+  }
+}
+SxClass.register(RenderCachePolygon)

package/lib/sexpr/classes/SchematicText.ts

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