kicadts 0.0.1

package/lib/sexpr/classes/Segment.ts

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

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

package/lib/sexpr/classes/SegmentLocked.ts

@@ -0,0 +1,33 @@
+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 SegmentLocked extends SxPrimitiveBoolean {
+  static override token = "locked"
+  static override parentToken = "segment"
+  override token = "locked"
+
+  constructor(value: boolean) {
+    super(value)
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SegmentLocked {
+    const [rawValue] = primitiveSexprs
+    if (typeof rawValue === "boolean") {
+      return new SegmentLocked(rawValue)
+    }
+    if (typeof rawValue === "string") {
+      return new SegmentLocked(truthyStrings.has(rawValue.toLowerCase()))
+    }
+    return new SegmentLocked(false)
+  }
+
+  override getString(): string {
+    return `(locked ${this.value ? "yes" : "no"})`
+  }
+}
+SxClass.register(SegmentLocked)

package/lib/sexpr/classes/SegmentNet.ts

@@ -0,0 +1,62 @@
+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 SegmentNet extends SxClass {
+  static override token = "net"
+  static override parentToken = "segment"
+  override 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[],
+  ): SegmentNet {
+    const [rawId, rawName] = primitiveSexprs
+    const id = toNumberValue(rawId)
+    if (id === undefined) {
+      throw new Error("net expects a numeric identifier")
+    }
+    const name = rawName === undefined ? undefined : toStringValue(rawName)
+    return new SegmentNet(id, name ?? undefined)
+  }
+
+  get id(): number {
+    return this._id
+  }
+
+  set id(value: number) {
+    this._id = value
+  }
+
+  get name(): string | undefined {
+    return this._name
+  }
+
+  set name(value: string | undefined) {
+    this._name = value === "" ? undefined : value
+  }
+
+  toObject(): { id: number; name?: string } {
+    return this._name === undefined ? { id: this._id } : { id: this._id, name: this._name }
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    const namePart = this._name ? ` ${quoteSExprString(this._name)}` : ""
+    return `(net ${this._id}${namePart})`
+  }
+}
+SxClass.register(SegmentNet)

package/lib/sexpr/classes/SegmentStart.ts

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