kicadts 0.0.1

package/lib/sexpr/classes/GrLineEnd.ts

@@ -0,0 +1,61 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { toNumberValue } from "../utils/toNumberValue"
+
+export class GrLineEnd extends SxClass {
+  static override token = "end"
+  static override parentToken = "gr_line"
+  override token = "end"
+
+  private _x: number
+  private _y: number
+
+  constructor(x: number, y: number) {
+    super()
+    this._x = x
+    this._y = y
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): GrLineEnd {
+    const [rawX, rawY] = primitiveSexprs
+    const x = toNumberValue(rawX)
+    const y = toNumberValue(rawY)
+
+    if (x === undefined || y === undefined) {
+      throw new Error("gr_line end expects two numeric arguments")
+    }
+
+    return new GrLineEnd(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
+  }
+
+  toObject(): { x: number; y: number } {
+    return { x: this._x, y: this._y }
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(end ${this._x} ${this._y})`
+  }
+}
+SxClass.register(GrLineEnd)

package/lib/sexpr/classes/GrLineLocked.ts

@@ -0,0 +1,40 @@
+import { SxClass } from "../base-classes/SxClass"
+import { SxPrimitiveBoolean } from "../base-classes/SxPrimitiveBoolean"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+
+const truthyStrings = new Set(["true", "yes", "1"])
+
+export class GrLineLocked extends SxPrimitiveBoolean {
+  static override token = "locked"
+  static override parentToken = "gr_line"
+  override token = "locked"
+
+  constructor(value: boolean) {
+    super(value)
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): GrLineLocked {
+    const [rawValue] = primitiveSexprs
+
+    if (rawValue === undefined) {
+      return new GrLineLocked(true)
+    }
+
+    if (typeof rawValue === "boolean") {
+      return new GrLineLocked(rawValue)
+    }
+
+    if (typeof rawValue === "string") {
+      return new GrLineLocked(truthyStrings.has(rawValue.toLowerCase()))
+    }
+
+    return new GrLineLocked(false)
+  }
+
+  override getString(): string {
+    return `(locked ${this.value ? "yes" : "no"})`
+  }
+}
+SxClass.register(GrLineLocked)

package/lib/sexpr/classes/GrLineStart.ts

@@ -0,0 +1,61 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { toNumberValue } from "../utils/toNumberValue"
+
+export class GrLineStart extends SxClass {
+  static override token = "start"
+  static override parentToken = "gr_line"
+  override token = "start"
+
+  private _x: number
+  private _y: number
+
+  constructor(x: number, y: number) {
+    super()
+    this._x = x
+    this._y = y
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): GrLineStart {
+    const [rawX, rawY] = primitiveSexprs
+    const x = toNumberValue(rawX)
+    const y = toNumberValue(rawY)
+
+    if (x === undefined || y === undefined) {
+      throw new Error("gr_line start expects two numeric arguments")
+    }
+
+    return new GrLineStart(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
+  }
+
+  toObject(): { x: number; y: number } {
+    return { x: this._x, y: this._y }
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(start ${this._x} ${this._y})`
+  }
+}
+SxClass.register(GrLineStart)

package/lib/sexpr/classes/GrText.ts

@@ -0,0 +1,202 @@
+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 { Xy } from "./Xy"
+import { Layer } from "./Layer"
+import { TextEffects } from "./TextEffects"
+import { Uuid } from "./Uuid"
+
+export interface GrTextPosition {
+  x: number
+  y: number
+  angle?: number
+}
+
+const SUPPORTED_SINGLE_TOKENS = new Set([
+  "at",
+  "xy",
+  "layer",
+  "uuid",
+  "effects",
+])
+
+export class GrText extends SxClass {
+  static override token = "gr_text"
+  override token = "gr_text"
+
+  private _text = ""
+  private _sxPosition?: At | Xy
+  private _sxLayer?: Layer
+  private _sxUuid?: Uuid
+  private _sxEffects?: TextEffects
+
+  constructor(text = "") {
+    super()
+    this.text = text
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): GrText {
+    if (primitiveSexprs.length === 0) {
+      throw new Error("gr_text requires a text argument")
+    }
+
+    const [rawText, ...rest] = primitiveSexprs
+    const text = toStringValue(rawText)
+    if (text === undefined) {
+      throw new Error("gr_text text must be a string value")
+    }
+
+    const grText = new GrText(text)
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(rest, this.token)
+
+    const unexpectedTokens = new Set<string>()
+    for (const token of Object.keys(propertyMap)) {
+      if (!SUPPORTED_SINGLE_TOKENS.has(token)) {
+        unexpectedTokens.add(token)
+      }
+    }
+    for (const token of Object.keys(arrayPropertyMap)) {
+      if (!SUPPORTED_SINGLE_TOKENS.has(token)) {
+        unexpectedTokens.add(token)
+        continue
+      }
+      if (arrayPropertyMap[token]!.length > 1) {
+        throw new Error(
+          `gr_text does not support repeated child tokens: ${token}`,
+        )
+      }
+    }
+
+    if (unexpectedTokens.size > 0) {
+      throw new Error(
+        `Unsupported child tokens inside gr_text expression: ${[...unexpectedTokens].join(", ")}`,
+      )
+    }
+
+    for (const primitive of rest) {
+      if (Array.isArray(primitive)) continue
+      throw new Error(
+        `gr_text encountered unexpected primitive child: ${JSON.stringify(primitive)}`,
+      )
+    }
+
+    const atInstance = propertyMap.at as At | undefined
+    const xyInstance = propertyMap.xy as Xy | undefined
+    if (atInstance && xyInstance) {
+      throw new Error("gr_text cannot include both at and xy tokens")
+    }
+
+    grText._sxPosition = atInstance ?? xyInstance
+    grText._sxLayer = propertyMap.layer as Layer | undefined
+    grText._sxUuid = propertyMap.uuid as Uuid | undefined
+    grText._sxEffects = propertyMap.effects as TextEffects | undefined
+
+    if (!grText._sxPosition) {
+      throw new Error("gr_text requires a position child token")
+    }
+    if (!grText._sxLayer) {
+      throw new Error("gr_text requires a layer child token")
+    }
+    if (!grText._sxUuid) {
+      throw new Error("gr_text requires a uuid child token")
+    }
+    if (!grText._sxEffects) {
+      throw new Error("gr_text requires an effects child token")
+    }
+
+    return grText
+  }
+
+  get text(): string {
+    return this._text
+  }
+
+  set text(value: string) {
+    this._text = value
+  }
+
+  get position(): At | Xy | undefined {
+    return this._sxPosition
+  }
+
+  set position(
+    value: At | Xy | GrTextPosition | undefined,
+  ) {
+    if (value === undefined) {
+      this._sxPosition = undefined
+      return
+    }
+    if (value instanceof At || value instanceof Xy) {
+      this._sxPosition = value
+      return
+    }
+    const { x, y, angle } = value
+    if (angle !== undefined) {
+      this._sxPosition = new At([x, y, angle])
+    } else {
+      this._sxPosition = new Xy(x, y)
+    }
+  }
+
+  get layer(): Layer | undefined {
+    return this._sxLayer
+  }
+
+  set layer(value: Layer | string | Array<string | number> | 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
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxPosition) children.push(this._sxPosition)
+    if (this._sxLayer) children.push(this._sxLayer)
+    if (this._sxUuid) children.push(this._sxUuid)
+    if (this._sxEffects) children.push(this._sxEffects)
+    return children
+  }
+
+  override getString(): string {
+    const lines = ["(gr_text", `  ${quoteSExprString(this._text)}`]
+    for (const child of this.getChildren()) {
+      lines.push(child.getStringIndented())
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(GrText)

package/lib/sexpr/classes/Image.ts

@@ -0,0 +1,256 @@
+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 { Layer } from "./Layer"
+import { Uuid } from "./Uuid"
+import { At } from "./At"
+import { Xy } from "./Xy"
+
+const SUPPORTED_SINGLE_TOKENS = new Set([
+  "at",
+  "xy",
+  "scale",
+  "layer",
+  "uuid",
+  "data",
+])
+
+const SUPPORTED_MULTI_TOKENS = new Set<string>()
+
+export class Image extends SxClass {
+  static override token = "image"
+  token = "image"
+
+  private _sxPosition?: At | Xy
+  private _sxScale?: ImageScale
+  private _sxLayer?: Layer
+  private _sxUuid?: Uuid
+  private _sxData?: ImageData
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Image {
+    const image = new Image()
+
+    const structuredPrimitives: PrimitiveSExpr[] = []
+
+    for (const primitive of primitiveSexprs) {
+      if (!Array.isArray(primitive) || primitive.length === 0) {
+        throw new Error(
+          `image encountered invalid child expression: ${JSON.stringify(primitive)}`,
+        )
+      }
+
+      structuredPrimitives.push(primitive)
+    }
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(structuredPrimitives, this.token)
+
+    for (const token of Object.keys(propertyMap)) {
+      if (!SUPPORTED_SINGLE_TOKENS.has(token)) {
+        throw new Error(
+          `image encountered unsupported child token "${token}"`,
+        )
+      }
+    }
+
+    for (const [token, entries] of Object.entries(arrayPropertyMap)) {
+      if (!SUPPORTED_SINGLE_TOKENS.has(token)) {
+        throw new Error(
+          `image encountered unsupported child token "${token}"`,
+        )
+      }
+      if (!SUPPORTED_MULTI_TOKENS.has(token) && entries.length > 1) {
+        throw new Error(
+          `image does not support repeated child token "${token}"`,
+        )
+      }
+    }
+
+    const atInstance = propertyMap.at as At | undefined
+    const xyInstance = propertyMap.xy as Xy | undefined
+    if (atInstance && xyInstance) {
+      throw new Error("image cannot include both at and xy child tokens")
+    }
+
+    image._sxPosition = atInstance ?? xyInstance
+    image._sxScale = propertyMap.scale as ImageScale | undefined
+    image._sxLayer = propertyMap.layer as Layer | undefined
+    image._sxUuid = propertyMap.uuid as Uuid | undefined
+    image._sxData = propertyMap.data as ImageData | undefined
+
+    return image
+  }
+
+  get position(): At | Xy | undefined {
+    return this._sxPosition
+  }
+
+  set position(value: At | Xy | undefined) {
+    this._sxPosition = value
+  }
+
+  get scale(): ImageScale | undefined {
+    return this._sxScale
+  }
+
+  set scale(value: ImageScale | number | undefined) {
+    if (value === undefined) {
+      this._sxScale = undefined
+      return
+    }
+    this._sxScale = value instanceof ImageScale ? value : new ImageScale(value)
+  }
+
+  get layer(): Layer | undefined {
+    return this._sxLayer
+  }
+
+  set layer(value: Layer | string | string[] | undefined) {
+    if (value === undefined) {
+      this._sxLayer = undefined
+      return
+    }
+    if (value instanceof Layer) {
+      this._sxLayer = value
+    } else {
+      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 data(): ImageData | undefined {
+    return this._sxData
+  }
+
+  set data(value: ImageData | string | string[] | undefined) {
+    if (value === undefined) {
+      this._sxData = undefined
+      return
+    }
+    if (value instanceof ImageData) {
+      this._sxData = value
+    } else if (Array.isArray(value)) {
+      this._sxData = ImageData.fromStrings(value)
+    } else {
+      this._sxData = ImageData.fromStrings([value])
+    }
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxPosition) children.push(this._sxPosition)
+    if (this._sxScale) children.push(this._sxScale)
+    if (this._sxLayer) children.push(this._sxLayer)
+    if (this._sxUuid) children.push(this._sxUuid)
+    if (this._sxData) children.push(this._sxData)
+    return children
+  }
+}
+SxClass.register(Image)
+
+export class ImageScale extends SxClass {
+  static override token = "scale"
+  static override parentToken = "image"
+  token = "scale"
+
+  value: number
+
+  constructor(value: number) {
+    super()
+    this.value = value
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): ImageScale {
+    const [raw] = primitiveSexprs
+    const numeric = toNumberValue(raw)
+    return new ImageScale(numeric ?? 1)
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(scale ${this.value})`
+  }
+}
+SxClass.register(ImageScale)
+
+export class ImageData extends SxClass {
+  static override token = "data"
+  static override parentToken = "image"
+  token = "data"
+
+  private _chunks: string[]
+
+  constructor(chunks: string[] = []) {
+    super()
+    this._chunks = chunks
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): ImageData {
+    const chunks = primitiveSexprs.map((primitive) => primitiveToChunk(primitive))
+    return new ImageData(chunks)
+  }
+
+  static fromStrings(values: string[]): ImageData {
+    return new ImageData(values)
+  }
+
+  get chunks(): string[] {
+    return [...this._chunks]
+  }
+
+  set chunks(values: string[]) {
+    this._chunks = [...values]
+  }
+
+  get value(): string {
+    return this._chunks.join("")
+  }
+
+  set value(data: string) {
+    this._chunks = [data]
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    if (this._chunks.length === 0) {
+      return "(data)"
+    }
+    const rendered = this._chunks.map((chunk) => quoteSExprString(chunk)).join(" ")
+    return `(data ${rendered})`
+  }
+}
+SxClass.register(ImageData)
+
+function primitiveToChunk(value: PrimitiveSExpr): string {
+  const stringValue = toStringValue(value)
+  if (stringValue !== undefined) {
+    return stringValue
+  }
+  return printSExpr(value)
+}

package/lib/sexpr/classes/InBom.ts

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