kicadts 0.0.2 → 0.0.4

package/lib/sexpr/classes/PcbGeneratorVersion.ts

@@ -1,16 +0,0 @@
-import { SxPrimitiveString } from "../base-classes/SxPrimitiveString"
-import { SxClass } from "../base-classes/SxClass"
-import { quoteSExprString } from "../utils/quoteSExprString"
-
-const isSymbol = (value: string) => /^[A-Za-z0-9._-]+$/.test(value)
-
-export class PcbGeneratorVersion extends SxPrimitiveString {
-  static override token = "generator_version"
-  static override parentToken = "kicad_pcb"
-  token = "generator_version"
-
-  override getString(): string {
-    return `(generator_version ${isSymbol(this.value) ? this.value : quoteSExprString(this.value)})`
-  }
-}
-SxClass.register(PcbGeneratorVersion)

package/lib/sexpr/classes/PcbLayerDefinition.ts

@@ -1,106 +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 PcbLayerDefinition extends SxClass {
-  static override token = "__pcb_layer_definition__"
-  static override parentToken = "layers"
-  token = "__pcb_layer_definition__"
-
-  private _index?: number
-  private _name?: string
-  private _type?: string
-  private _userName?: string
-
-  constructor(options: {
-    index?: number
-    name?: string
-    type?: string
-    userName?: string
-  }) {
-    super()
-    this._index = options.index
-    this._name = options.name
-    this._type = options.type
-    this._userName = options.userName
-  }
-
-  static fromPrimitive(primitive: PrimitiveSExpr): PcbLayerDefinition {
-    if (!Array.isArray(primitive) || primitive.length < 3) {
-      throw new Error(
-        `layers entry must be an array with at least index, name, and type: ${JSON.stringify(primitive)}`,
-      )
-    }
-    const [rawIndex, rawName, rawType, rawUser] = primitive
-    const index = toNumberValue(rawIndex)
-    const name = toStringValue(rawName)
-    const type = toStringValue(rawType)
-    const userName = rawUser === undefined ? undefined : toStringValue(rawUser)
-
-    if (index === undefined || name === undefined || type === undefined) {
-      throw new Error(
-        `layers entry is missing required values: ${JSON.stringify(primitive)}`,
-      )
-    }
-
-    return new PcbLayerDefinition({ index, name, type, userName })
-  }
-
-  get index(): number | undefined {
-    return this._index
-  }
-
-  set index(value: number | undefined) {
-    this._index = value
-  }
-
-  get name(): string | undefined {
-    return this._name
-  }
-
-  set name(value: string | undefined) {
-    this._name = value
-  }
-
-  get type(): string | undefined {
-    return this._type
-  }
-
-  set type(value: string | undefined) {
-    this._type = value
-  }
-
-  get userName(): string | undefined {
-    return this._userName
-  }
-
-  set userName(value: string | undefined) {
-    this._userName = value
-  }
-
-  override getChildren(): SxClass[] {
-    return []
-  }
-
-  override getString(): string {
-    if (
-      this._index === undefined ||
-      this._name === undefined ||
-      this._type === undefined
-    ) {
-      return "()"
-    }
-    const tokens = [
-      String(this._index),
-      quoteSExprString(this._name),
-      this._type,
-    ]
-    if (this._userName !== undefined) {
-      tokens.push(quoteSExprString(this._userName))
-    }
-    return `(${tokens.join(" ")})`
-  }
-}
-SxClass.register(PcbLayerDefinition)

package/lib/sexpr/classes/PcbLayers.ts

@@ -1,34 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { PcbLayerDefinition } from "./PcbLayerDefinition"
-
-export class PcbLayers extends SxClass {
-  static override token = "layers"
-  static override parentToken = "kicad_pcb"
-  token = "layers"
-
-  private _definitions: PcbLayerDefinition[] = []
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): PcbLayers {
-    const layers = new PcbLayers()
-    layers._definitions = primitiveSexprs.map((primitive) =>
-      PcbLayerDefinition.fromPrimitive(primitive),
-    )
-    return layers
-  }
-
-  get definitions(): PcbLayerDefinition[] {
-    return [...this._definitions]
-  }
-
-  set definitions(value: PcbLayerDefinition[]) {
-    this._definitions = [...value]
-  }
-
-  override getChildren(): SxClass[] {
-    return [...this._definitions]
-  }
-}
-SxClass.register(PcbLayers)

package/lib/sexpr/classes/PcbNet.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 PcbNet extends SxClass {
-  static override token = "net"
-  static override parentToken = "kicad_pcb"
-  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[],
-  ): PcbNet {
-    const id = toNumberValue(primitiveSexprs[0])
-    const name = toStringValue(primitiveSexprs[1])
-    if (id === undefined || name === undefined) {
-      throw new Error("net requires numeric id and string name")
-    }
-    return new PcbNet(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(PcbNet)

package/lib/sexpr/classes/PcbVersion.ts

@@ -1,9 +0,0 @@
-import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
-import { SxClass } from "../base-classes/SxClass"
-
-export class PcbVersion extends SxPrimitiveNumber {
-  static override token = "version"
-  static override parentToken = "kicad_pcb"
-  token = "version"
-}
-SxClass.register(PcbVersion)

package/lib/sexpr/classes/Property.ts

@@ -1,301 +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"
-import { At, type AtInput } 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 interface PropertyConstructorParams {
-  key?: string
-  value?: string
-  position?: AtInput | Xy
-  layer?: Layer | Array<string | number> | string
-  uuid?: string | Uuid
-  effects?: TextEffects
-  unlocked?: boolean | PropertyUnlocked
-  hidden?: boolean | PropertyHide
-}
-
-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(
-    keyOrParams: string | PropertyConstructorParams = {},
-    value = "",
-  ) {
-    super()
-
-    // Support both old constructor signature and new params interface
-    if (typeof keyOrParams === "string") {
-      this._key = keyOrParams
-      this._value = value
-    } else {
-      const params = keyOrParams
-      if (params.key !== undefined) {
-        this._key = params.key
-      }
-      if (params.value !== undefined) {
-        this._value = params.value
-      }
-      if (params.position !== undefined) {
-        this.position = params.position
-      }
-      if (params.layer !== undefined) {
-        this.layer = params.layer
-      }
-      if (params.uuid !== undefined) {
-        this.uuid = params.uuid
-      }
-      if (params.effects !== undefined) {
-        this.effects = params.effects
-      }
-      if (params.unlocked !== undefined) {
-        if (params.unlocked instanceof PropertyUnlocked) {
-          this._sxUnlocked = params.unlocked
-        } else {
-          this.unlocked = params.unlocked
-        }
-      }
-      if (params.hidden !== undefined) {
-        if (params.hidden instanceof PropertyHide) {
-          this._sxHide = params.hidden
-        } else {
-          this.hidden = params.hidden
-        }
-      }
-    }
-  }
-
-  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: AtInput | Xy | undefined) {
-    if (value === undefined) {
-      this._sxAt = undefined
-      this._sxXy = undefined
-      return
-    }
-    if (value instanceof Xy) {
-      this._sxXy = value
-      this._sxAt = undefined
-      return
-    }
-    // Handle AtInput (At, array, or object)
-    this._sxAt = At.from(value as AtInput)
-    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

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

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

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