kicadts 0.0.2 → 0.0.4

package/lib/sexpr/classes/RenderCache.ts

@@ -1,221 +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"
-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

@@ -1,171 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { quoteSExprString } from "../utils/quoteSExprString"
-import { toStringValue } from "../utils/toStringValue"
-import { At, type AtInput } 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 interface SchematicTextConstructorParams {
-  value?: string
-  excludeFromSim?: boolean | ExcludeFromSim
-  at?: AtInput
-  effects?: TextEffects
-  uuid?: string | 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
-
-  constructor(params: SchematicTextConstructorParams = {}) {
-    super()
-
-    if (params.value !== undefined) {
-      this.value = params.value
-    }
-
-    if (params.excludeFromSim !== undefined) {
-      this.excludeFromSim =
-        typeof params.excludeFromSim === "boolean"
-          ? params.excludeFromSim
-          : params.excludeFromSim.value
-    }
-
-    if (params.at !== undefined) {
-      this.at = params.at
-    }
-
-    if (params.effects !== undefined) {
-      this.effects = params.effects
-    }
-
-    if (params.uuid !== undefined) {
-      this.uuid = params.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: AtInput | undefined) {
-    this._sxAt = value !== undefined ? At.from(value) : undefined
-  }
-
-  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)

package/lib/sexpr/classes/Segment.ts

@@ -1,243 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { Layer } from "./Layer"
-import { SegmentEnd } from "./SegmentEnd"
-import { SegmentLocked } from "./SegmentLocked"
-import { SegmentNet } from "./SegmentNet"
-import { SegmentStart } from "./SegmentStart"
-import { Uuid } from "./Uuid"
-import { Width } from "./Width"
-
-const SUPPORTED_SINGLE_TOKENS = new Set([
-  "start",
-  "end",
-  "width",
-  "layer",
-  "net",
-  "uuid",
-  "locked",
-])
-
-export interface SegmentConstructorParams {
-  start?: SegmentStart | { x: number; y: number }
-  end?: SegmentEnd | { x: number; y: number }
-  width?: Width | number
-  layer?: Layer | string | Array<string | number>
-  net?: SegmentNet | { id: number; name?: string }
-  uuid?: Uuid | string
-  locked?: boolean
-}
-
-export class Segment extends SxClass {
-  static override token = "segment"
-  override token = "segment"
-
-  private _sxStart?: SegmentStart
-  private _sxEnd?: SegmentEnd
-  private _sxWidth?: Width
-  private _sxLayer?: Layer
-  private _sxNet?: SegmentNet
-  private _sxUuid?: Uuid
-  private _sxLocked?: SegmentLocked
-
-  constructor(params: SegmentConstructorParams = {}) {
-    super()
-    if (params.start !== undefined) this.start = params.start
-    if (params.end !== undefined) this.end = params.end
-    if (params.width !== undefined) this.width = params.width
-    if (params.layer !== undefined) this.layer = params.layer
-    if (params.net !== undefined) this.net = params.net
-    if (params.uuid !== undefined) this.uuid = params.uuid
-    if (params.locked !== undefined) this.locked = params.locked
-  }
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): Segment {
-    const segment = new Segment()
-
-    const { propertyMap, arrayPropertyMap } =
-      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
-
-    const unexpectedSingleTokens = Object.keys(propertyMap).filter(
-      (token) => !SUPPORTED_SINGLE_TOKENS.has(token),
-    )
-    if (unexpectedSingleTokens.length > 0) {
-      throw new Error(
-        `Unsupported child tokens inside segment expression: ${unexpectedSingleTokens.join(", ")}`,
-      )
-    }
-
-    for (const [token, entries] of Object.entries(arrayPropertyMap)) {
-      if (!SUPPORTED_SINGLE_TOKENS.has(token)) {
-        throw new Error(
-          `Unsupported child tokens inside segment expression: ${token}`,
-        )
-      }
-      if (entries.length > 1) {
-        throw new Error(
-          `Segment does not support repeated child tokens: ${token}`,
-        )
-      }
-    }
-
-    segment._sxStart =
-      (arrayPropertyMap.start?.[0] as SegmentStart | undefined) ??
-      (propertyMap.start as SegmentStart | undefined)
-    segment._sxEnd =
-      (arrayPropertyMap.end?.[0] as SegmentEnd | undefined) ??
-      (propertyMap.end as SegmentEnd | undefined)
-    segment._sxWidth =
-      (arrayPropertyMap.width?.[0] as Width | undefined) ??
-      (propertyMap.width as Width | undefined)
-    segment._sxLayer =
-      (arrayPropertyMap.layer?.[0] as Layer | undefined) ??
-      (propertyMap.layer as Layer | undefined)
-    segment._sxNet =
-      (arrayPropertyMap.net?.[0] as SegmentNet | undefined) ??
-      (propertyMap.net as SegmentNet | undefined)
-    const locked =
-      (arrayPropertyMap.locked?.[0] as SegmentLocked | undefined) ??
-      (propertyMap.locked as SegmentLocked | undefined)
-    segment._sxLocked = locked && locked.value ? locked : undefined
-    segment._sxUuid =
-      (arrayPropertyMap.uuid?.[0] as Uuid | undefined) ??
-      (propertyMap.uuid as Uuid | undefined)
-
-    return segment
-  }
-
-  get start(): SegmentStart | undefined {
-    return this._sxStart
-  }
-
-  set start(value: SegmentStart | { x: number; y: number } | undefined) {
-    this._sxStart = this.normalizeStart(value)
-  }
-
-  get end(): SegmentEnd | undefined {
-    return this._sxEnd
-  }
-
-  set end(value: SegmentEnd | { x: number; y: number } | undefined) {
-    this._sxEnd = this.normalizeEnd(value)
-  }
-
-  get startPoint(): { x: number; y: number } | undefined {
-    return this._sxStart?.toObject()
-  }
-
-  get endPoint(): { x: number; y: number } | undefined {
-    return this._sxEnd?.toObject()
-  }
-
-  get width(): number | undefined {
-    return this._sxWidth?.value
-  }
-
-  set width(value: Width | number | undefined) {
-    if (value === undefined) {
-      this._sxWidth = undefined
-      return
-    }
-    this._sxWidth = value instanceof Width ? value : new Width(value)
-  }
-
-  get widthClass(): Width | undefined {
-    return this._sxWidth
-  }
-
-  set widthClass(value: Width | undefined) {
-    this._sxWidth = value
-  }
-
-  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 net(): SegmentNet | undefined {
-    return this._sxNet
-  }
-
-  set net(value: SegmentNet | { id: number; name?: string } | undefined) {
-    if (value === undefined) {
-      this._sxNet = undefined
-      return
-    }
-    if (value instanceof SegmentNet) {
-      this._sxNet = value
-      return
-    }
-    this._sxNet = new SegmentNet(value.id, value.name)
-  }
-
-  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 locked(): boolean {
-    return this._sxLocked?.value ?? false
-  }
-
-  set locked(value: boolean) {
-    this._sxLocked = value ? new SegmentLocked(true) : undefined
-  }
-
-  override getChildren(): SxClass[] {
-    const children: SxClass[] = []
-    if (this._sxStart) children.push(this._sxStart)
-    if (this._sxEnd) children.push(this._sxEnd)
-    if (this._sxWidth) children.push(this._sxWidth)
-    if (this._sxLayer) children.push(this._sxLayer)
-    if (this._sxNet) children.push(this._sxNet)
-    if (this._sxLocked) children.push(this._sxLocked)
-    if (this._sxUuid) children.push(this._sxUuid)
-    return children
-  }
-
-  private normalizeStart(
-    value: SegmentStart | { x: number; y: number } | undefined,
-  ): SegmentStart | undefined {
-    if (value === undefined) {
-      return undefined
-    }
-    if (value instanceof SegmentStart) {
-      return value
-    }
-    return new SegmentStart(value.x, value.y)
-  }
-
-  private normalizeEnd(
-    value: SegmentEnd | { x: number; y: number } | undefined,
-  ): SegmentEnd | undefined {
-    if (value === undefined) {
-      return undefined
-    }
-    if (value instanceof SegmentEnd) {
-      return value
-    }
-    return new SegmentEnd(value.x, value.y)
-  }
-}
-SxClass.register(Segment)

package/lib/sexpr/classes/SegmentEnd.ts

@@ -1,59 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { toNumberValue } from "../utils/toNumberValue"
-
-export class SegmentEnd extends SxClass {
-  static override token = "end"
-  static override parentToken = "segment"
-  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[],
-  ): SegmentEnd {
-    const [rawX, rawY] = primitiveSexprs
-    const x = toNumberValue(rawX)
-    const y = toNumberValue(rawY)
-    if (x === undefined || y === undefined) {
-      throw new Error("end expects two numeric arguments")
-    }
-    return new SegmentEnd(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(SegmentEnd)