kicadts 0.0.1

package/lib/sexpr/classes/SheetInstances.ts

@@ -0,0 +1,168 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { toStringValue } from "../utils/toStringValue"
+
+export class SheetInstances extends SxClass {
+  static override token = "instances"
+  static override parentToken = "sheet"
+  token = "instances"
+
+  projects: SheetInstancesProject[] = []
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SheetInstances {
+    const instances = new SheetInstances()
+    const { arrayPropertyMap } = SxClass.parsePrimitivesToClassProperties(
+      primitiveSexprs,
+      "sheet_instances",
+    )
+
+    instances.projects =
+      (arrayPropertyMap.project as SheetInstancesProject[]) ?? []
+
+    return instances
+  }
+
+  override getChildren(): SxClass[] {
+    return [...this.projects]
+  }
+
+  override getString(): string {
+    const lines = ["(instances"]
+    for (const project of this.projects) {
+      lines.push(project.getStringIndented())
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(SheetInstances)
+
+export class SheetInstancesProject extends SxClass {
+  static override token = "project"
+  static override parentToken = "sheet_instances"
+  token = "project"
+
+  name: string
+  paths: SheetInstancePath[] = []
+
+  constructor(name: string) {
+    super()
+    this.name = name
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SheetInstancesProject {
+    const [namePrimitive, ...rest] = primitiveSexprs
+    const name = toStringValue(namePrimitive)
+    if (name === undefined) {
+      throw new Error("sheet project instances require a project name")
+    }
+
+    const project = new SheetInstancesProject(name)
+
+    const { arrayPropertyMap } = SxClass.parsePrimitivesToClassProperties(
+      rest,
+      "sheet_project",
+    )
+
+    project.paths = (arrayPropertyMap.path as SheetInstancePath[]) ?? []
+
+    return project
+  }
+
+  override getChildren(): SxClass[] {
+    return [...this.paths]
+  }
+
+  override getString(): string {
+    const lines = [`(project ${quoteSExprString(this.name)}`]
+    for (const path of this.paths) {
+      lines.push(path.getStringIndented())
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(SheetInstancesProject)
+
+export class SheetInstancePath extends SxClass {
+  static override token = "path"
+  static override parentToken = "sheet_project"
+  token = "path"
+
+  value: string
+  pages: SheetInstancePage[] = []
+
+  constructor(value: string) {
+    super()
+    this.value = value
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SheetInstancePath {
+    const [pathPrimitive, ...rest] = primitiveSexprs
+    const value = toStringValue(pathPrimitive)
+    if (value === undefined) {
+      throw new Error("sheet instance path value must be a string")
+    }
+
+    const path = new SheetInstancePath(value)
+
+    const { arrayPropertyMap } = SxClass.parsePrimitivesToClassProperties(
+      rest,
+      "sheet_path",
+    )
+
+    path.pages = (arrayPropertyMap.page as SheetInstancePage[]) ?? []
+
+    return path
+  }
+
+  override getChildren(): SxClass[] {
+    return [...this.pages]
+  }
+
+  override getString(): string {
+    const lines = [`(path ${quoteSExprString(this.value)}`]
+    for (const page of this.pages) {
+      lines.push(page.getStringIndented())
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(SheetInstancePath)
+
+export class SheetInstancePage extends SxClass {
+  static override token = "page"
+  static override parentToken = "sheet_path"
+  token = "page"
+
+  value: string
+
+  constructor(value: string) {
+    super()
+    this.value = value
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SheetInstancePage {
+    const [valuePrimitive] = primitiveSexprs
+    const value = toStringValue(valuePrimitive)
+    if (value === undefined) {
+      throw new Error("sheet instance page value must be a string")
+    }
+    return new SheetInstancePage(value)
+  }
+
+  override getString(): string {
+    return `(page ${quoteSExprString(this.value)})`
+  }
+}
+SxClass.register(SheetInstancePage)

package/lib/sexpr/classes/SheetInstancesRoot.ts

@@ -0,0 +1,165 @@
+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 SUPPORTED_ARRAY_TOKENS = new Set(["page"])
+
+export class SheetInstancesRoot extends SxClass {
+  static override token = "sheet_instances"
+  override token = "sheet_instances"
+
+  private _paths: SheetInstancesRootPath[] = []
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SheetInstancesRoot {
+    const sheetInstances = new SheetInstancesRoot()
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
+
+    const unsupportedSingularTokens = Object.keys(propertyMap).filter(
+      (token) => token !== "path",
+    )
+    if (unsupportedSingularTokens.length > 0) {
+      throw new Error(
+        `Unsupported singular child tokens inside sheet_instances expression: ${unsupportedSingularTokens.join(", ")}`,
+      )
+    }
+
+    const unsupportedArrayTokens = Object.keys(arrayPropertyMap).filter(
+      (token) => token !== "path",
+    )
+    if (unsupportedArrayTokens.length > 0) {
+      throw new Error(
+        `Unsupported repeated child tokens inside sheet_instances expression: ${unsupportedArrayTokens.join(", ")}`,
+      )
+    }
+
+    const paths = (arrayPropertyMap.path as SheetInstancesRootPath[]) ?? []
+    if (!paths.length && propertyMap.path) {
+      paths.push(propertyMap.path as SheetInstancesRootPath)
+    }
+    sheetInstances._paths = paths
+
+    return sheetInstances
+  }
+
+  get paths(): SheetInstancesRootPath[] {
+    return [...this._paths]
+  }
+
+  set paths(value: SheetInstancesRootPath[]) {
+    this._paths = [...value]
+  }
+
+  override getChildren(): SxClass[] {
+    return [...this._paths]
+  }
+}
+SxClass.register(SheetInstancesRoot)
+
+export class SheetInstancesRootPath extends SxClass {
+  static override token = "path"
+  static override parentToken = "sheet_instances"
+  override token = "path"
+
+  private _value = ""
+  private _pages: SheetInstancesRootPage[] = []
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SheetInstancesRootPath {
+    const [valuePrimitive, ...rest] = primitiveSexprs
+    const value = toStringValue(valuePrimitive)
+    if (value === undefined) {
+      throw new Error("sheet_instances path requires a string identifier")
+    }
+
+    const path = new SheetInstancesRootPath()
+    path._value = value
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(rest, "sheet_instances_path")
+
+    const unsupportedSingularTokens = Object.keys(propertyMap).filter(
+      (token) => !SUPPORTED_ARRAY_TOKENS.has(token),
+    )
+    if (unsupportedSingularTokens.length > 0) {
+      throw new Error(
+        `Unsupported singular child tokens inside sheet_instances path 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 sheet_instances path expression: ${unsupportedArrayTokens.join(", ")}`,
+      )
+    }
+
+    const pages = (arrayPropertyMap.page as SheetInstancesRootPage[]) ?? []
+    if (!pages.length && propertyMap.page) {
+      pages.push(propertyMap.page as SheetInstancesRootPage)
+    }
+    path._pages = pages
+
+    return path
+  }
+
+  get value(): string {
+    return this._value
+  }
+
+  set value(newValue: string) {
+    this._value = newValue
+  }
+
+  get pages(): SheetInstancesRootPage[] {
+    return [...this._pages]
+  }
+
+  set pages(value: SheetInstancesRootPage[]) {
+    this._pages = [...value]
+  }
+
+  override getChildren(): SxClass[] {
+    return [...this._pages]
+  }
+
+  override getString(): string {
+    const lines = [`(path ${quoteSExprString(this._value)}`]
+    for (const page of this._pages) {
+      lines.push(page.getStringIndented())
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(SheetInstancesRootPath)
+
+export class SheetInstancesRootPage extends SxPrimitiveString {
+  static override token = "page"
+  static override parentToken = "sheet_instances_path"
+  override token = "page"
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SheetInstancesRootPage {
+    const [valuePrimitive] = primitiveSexprs
+    const value = toStringValue(valuePrimitive)
+    if (value === undefined) {
+      throw new Error("sheet_instances page expects a string value")
+    }
+    return new SheetInstancesRootPage(value)
+  }
+
+  override getString(): string {
+    return `(page ${quoteSExprString(this.value)})`
+  }
+}
+SxClass.register(SheetInstancesRootPage)

package/lib/sexpr/classes/SheetPin.ts

@@ -0,0 +1,122 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { indentLines } from "../utils/indentLines"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { toStringValue } from "../utils/toStringValue"
+import { At } from "./At"
+import { TextEffects } from "./TextEffects"
+import { Uuid } from "./Uuid"
+
+export type SheetPinElectricalType =
+  | "input"
+  | "output"
+  | "bidirectional"
+  | "tri_state"
+  | "passive"
+
+const electricalTypes = new Set<SheetPinElectricalType>([
+  "input",
+  "output",
+  "bidirectional",
+  "tri_state",
+  "passive",
+])
+
+export class SheetPin extends SxClass {
+  static override token = "pin"
+  static override parentToken = "sheet"
+  token = "pin"
+
+  name = ""
+  electricalType: SheetPinElectricalType = "input"
+  private _sxAt?: At
+  private _sxEffects?: TextEffects
+  private _sxUuid?: Uuid
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SheetPin {
+    if (primitiveSexprs.length < 2) {
+      throw new Error("sheet pin requires a name and electrical type")
+    }
+
+    const [rawName, rawType, ...rest] = primitiveSexprs
+
+    const name = toStringValue(rawName)
+    if (name === undefined) {
+      throw new Error("sheet pin name must be a string")
+    }
+
+    const electricalType = toStringValue(rawType)
+    if (!electricalType || !electricalTypes.has(electricalType as SheetPinElectricalType)) {
+      throw new Error(
+        `sheet pin electrical type must be one of: ${Array.from(electricalTypes).join(", ")}`,
+      )
+    }
+
+    const pin = new SheetPin()
+    pin.name = name
+    pin.electricalType = electricalType as SheetPinElectricalType
+
+    const { propertyMap } = SxClass.parsePrimitivesToClassProperties(
+      rest,
+      this.token,
+    )
+
+    pin._sxAt = propertyMap.at as At | undefined
+    pin._sxEffects = propertyMap.effects as TextEffects | undefined
+    pin._sxUuid = propertyMap.uuid as Uuid | undefined
+
+    return pin
+  }
+
+  get position(): At | undefined {
+    return this._sxAt
+  }
+
+  set position(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._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 header = `(pin ${quoteSExprString(this.name)} ${this.electricalType}`
+    const bodyLines = this.getChildren().flatMap((child) =>
+      indentLines(child.getString()),
+    )
+
+    if (bodyLines.length === 0) {
+      return `${header})`
+    }
+
+    return [header, ...bodyLines, ")"].join("\n")
+  }
+}
+SxClass.register(SheetPin)

package/lib/sexpr/classes/SheetProperty.ts

@@ -0,0 +1,115 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { indentLines } from "../utils/indentLines"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { toStringValue } from "../utils/toStringValue"
+import { At } from "./At"
+import { TextEffects } from "./TextEffects"
+import { SymbolPropertyId as PropertyId } from "./Symbol"
+
+export class SheetProperty extends SxClass {
+  static override token = "property"
+  static override parentToken = "sheet"
+  token = "property"
+
+  key: string
+  value: string
+  private _sxId?: PropertyId
+  private _sxAt?: At
+  private _sxEffects?: TextEffects
+
+  constructor(params: {
+    key: string
+    value: string
+    id?: number | PropertyId
+    at?: At
+    effects?: TextEffects
+  }) {
+    super()
+    this.key = params.key
+    this.value = params.value
+    this.id = params.id
+    this.at = params.at
+    this.effects = params.effects
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SheetProperty {
+    const [rawKey, rawValue, ...rest] = primitiveSexprs
+
+    const key = toStringValue(rawKey)
+    const value = toStringValue(rawValue)
+
+    if (key === undefined || value === undefined) {
+      throw new Error("sheet property requires string key and value")
+    }
+
+    const { propertyMap } = SxClass.parsePrimitivesToClassProperties(
+      rest,
+      this.token,
+    )
+
+    return new SheetProperty({
+      key,
+      value,
+      id: propertyMap.id as PropertyId | undefined,
+      at: propertyMap.at as At | undefined,
+      effects: propertyMap.effects as TextEffects | undefined,
+    })
+  }
+
+  get id(): number | undefined {
+    return this._sxId?.value
+  }
+
+  set id(value: number | PropertyId | undefined) {
+    if (value === undefined) {
+      this._sxId = undefined
+      return
+    }
+    this._sxId = value instanceof PropertyId ? value : new PropertyId(value)
+  }
+
+  get idClass(): PropertyId | undefined {
+    return this._sxId
+  }
+
+  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
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxId) children.push(this._sxId)
+    if (this._sxAt) children.push(this._sxAt)
+    if (this._sxEffects) children.push(this._sxEffects)
+    return children
+  }
+
+  override getString(): string {
+    const header = `(property ${quoteSExprString(this.key)} ${quoteSExprString(this.value)}`
+    const bodyLines = this.getChildren().flatMap((child) =>
+      indentLines(child.getString()),
+    )
+
+    if (bodyLines.length === 0) {
+      return `${header})`
+    }
+
+    return [header, ...bodyLines, ")"].join("\n")
+  }
+}
+SxClass.register(SheetProperty)

package/lib/sexpr/classes/SheetSize.ts

@@ -0,0 +1,44 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { indentLines } from "../utils/indentLines"
+import { quoteSExprString } from "../utils/quoteSExprString"
+import { toStringValue } from "../utils/toStringValue"
+import { At } from "./At"
+import { TextEffects } from "./TextEffects"
+import { SymbolPropertyId as PropertyId } from "./Symbol"
+import { toNumberValue } from "../utils/toNumberValue"
+
+export class SheetSize extends SxClass {
+  static override token = "size"
+  static override parentToken = "sheet"
+  token = "size"
+
+  width: number
+  height: number
+
+  constructor(width: number, height: number) {
+    super()
+    this.width = width
+    this.height = height
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SheetSize {
+    const width = toNumberValue(primitiveSexprs[0])
+    const height = toNumberValue(primitiveSexprs[1])
+    if (width === undefined || height === undefined) {
+      throw new Error("sheet size requires numeric width and height")
+    }
+    return new SheetSize(width, height)
+  }
+
+  toObject(): { width: number; height: number } {
+    return { width: this.width, height: this.height }
+  }
+
+  override getString(): string {
+    return `(size ${this.width} ${this.height})`
+  }
+}
+SxClass.register(SheetSize)

package/lib/sexpr/classes/Stroke.ts

@@ -0,0 +1,58 @@
+import { SxClass } from "../base-classes/SxClass"
+import { Width } from "./Width"
+import { StrokeType, type StrokeTypeString } from "./StrokeType"
+import { Color, type RGBAColor } from "./Color"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+
+export type StrokeProperty = Width | StrokeType | Color
+
+export class Stroke extends SxClass {
+  static override token = "stroke"
+  token = "stroke"
+
+  _sxWidth?: Width
+  _sxType?: StrokeType
+  _sxColor?: Color
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Stroke {
+    const stroke = new Stroke()
+
+    const { propertyMap } = SxClass.parsePrimitivesToClassProperties(
+      primitiveSexprs,
+      this.token,
+    )
+    stroke._sxWidth = propertyMap.width as Width
+    stroke._sxType = propertyMap.type as StrokeType
+    stroke._sxColor = propertyMap.color as Color
+
+    return stroke
+  }
+
+  get width(): number | undefined {
+    return this._sxWidth?.value
+  }
+
+  get type(): StrokeTypeString | undefined {
+    return this._sxType?.type
+  }
+
+  get color(): RGBAColor | undefined {
+    return this._sxColor?.color
+  }
+
+  set width(width: number) {
+    this._sxWidth = new Width(width)
+  }
+
+  set type(type: StrokeTypeString) {
+    this._sxType = new StrokeType(type)
+  }
+
+  set color(color: RGBAColor) {
+    // TODO accept color as string
+    this._sxColor = new Color([color.r, color.g, color.b, color.a])
+  }
+}
+SxClass.register(Stroke)

package/lib/sexpr/classes/StrokeType.ts

@@ -0,0 +1,34 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+
+export type StrokeTypeString =
+  | "dash"
+  | "dash_dot"
+  | "dash_dot_dot"
+  | "dot"
+  | "default"
+  | "solid"
+
+export class StrokeType extends SxClass {
+  static override token = "type"
+  static override parentToken = "stroke"
+  token = "type"
+
+  type: StrokeTypeString
+
+  constructor(type: StrokeTypeString) {
+    super()
+    this.type = type
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): StrokeType {
+    return new StrokeType(primitiveSexprs[0] as StrokeTypeString)
+  }
+
+  override getString() {
+    return `(type ${this.type})`
+  }
+}
+SxClass.register(StrokeType)