kicadts 0.0.2 → 0.0.4

package/lib/sexpr/classes/PadOptions.ts

@@ -1,181 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { toStringValue } from "../utils/toStringValue"
-
-export type PadOptionsClearanceType = "outline" | "convexhull"
-export type PadOptionsAnchorShape = "rect" | "circle"
-
-const CLEARANCE_TYPES: PadOptionsClearanceType[] = ["outline", "convexhull"]
-
-const ANCHOR_SHAPES: PadOptionsAnchorShape[] = ["rect", "circle"]
-
-export class PadOptions extends SxClass {
-  static override token = "options"
-  static override parentToken = "pad"
-  override token = "options"
-
-  private _sxClearance?: PadOptionsClearance
-  private _sxAnchor?: PadOptionsAnchor
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): PadOptions {
-    const options = new PadOptions()
-
-    for (const primitive of primitiveSexprs) {
-      if (!Array.isArray(primitive) || primitive.length === 0) {
-        throw new Error(
-          `pad options encountered invalid child expression: ${JSON.stringify(primitive)}`,
-        )
-      }
-
-      const parsed = SxClass.parsePrimitiveSexpr(primitive, {
-        parentToken: this.token,
-      })
-
-      if (!(parsed instanceof SxClass)) {
-        throw new Error(
-          `pad options child did not resolve to an SxClass: ${JSON.stringify(primitive)}`,
-        )
-      }
-
-      if (parsed instanceof PadOptionsClearance) {
-        if (options._sxClearance) {
-          throw new Error("pad options encountered duplicate clearance tokens")
-        }
-        options._sxClearance = parsed
-        continue
-      }
-
-      if (parsed instanceof PadOptionsAnchor) {
-        if (options._sxAnchor) {
-          throw new Error("pad options encountered duplicate anchor tokens")
-        }
-        options._sxAnchor = parsed
-        continue
-      }
-
-      throw new Error(
-        `pad options encountered unsupported token "${parsed.token}"`,
-      )
-    }
-
-    return options
-  }
-
-  get clearance(): PadOptionsClearanceType | undefined {
-    return this._sxClearance?.type
-  }
-
-  set clearance(value: PadOptionsClearanceType | undefined) {
-    this._sxClearance = value ? new PadOptionsClearance(value) : undefined
-  }
-
-  get anchor(): PadOptionsAnchorShape | undefined {
-    return this._sxAnchor?.shape
-  }
-
-  set anchor(value: PadOptionsAnchorShape | undefined) {
-    this._sxAnchor = value ? new PadOptionsAnchor(value) : undefined
-  }
-
-  override getChildren(): SxClass[] {
-    const children: SxClass[] = []
-    if (this._sxClearance) children.push(this._sxClearance)
-    if (this._sxAnchor) children.push(this._sxAnchor)
-    return children
-  }
-}
-SxClass.register(PadOptions)
-
-class PadOptionsClearance extends SxClass {
-  static override token = "clearance"
-  static override parentToken = "options"
-  override token = "clearance"
-
-  private _type: PadOptionsClearanceType
-
-  constructor(type: PadOptionsClearanceType) {
-    super()
-    this._type = type
-  }
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): PadOptionsClearance {
-    const [raw] = primitiveSexprs
-    const stringValue = toStringValue(raw)
-    if (stringValue === undefined) {
-      throw new Error("pad options clearance requires a string value")
-    }
-    if (!CLEARANCE_TYPES.includes(stringValue as PadOptionsClearanceType)) {
-      throw new Error(
-        `pad options clearance must be one of ${CLEARANCE_TYPES.join(", ")}`,
-      )
-    }
-    return new PadOptionsClearance(stringValue as PadOptionsClearanceType)
-  }
-
-  get type(): PadOptionsClearanceType {
-    return this._type
-  }
-
-  set type(value: PadOptionsClearanceType) {
-    this._type = value
-  }
-
-  override getChildren(): SxClass[] {
-    return []
-  }
-
-  override getString(): string {
-    return `(clearance ${this._type})`
-  }
-}
-SxClass.register(PadOptionsClearance)
-
-class PadOptionsAnchor extends SxClass {
-  static override token = "anchor"
-  static override parentToken = "options"
-  override token = "anchor"
-
-  private _shape: PadOptionsAnchorShape
-
-  constructor(shape: PadOptionsAnchorShape) {
-    super()
-    this._shape = shape
-  }
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): PadOptionsAnchor {
-    const [raw] = primitiveSexprs
-    const stringValue = toStringValue(raw)
-    if (stringValue === undefined) {
-      throw new Error("pad options anchor requires a string value")
-    }
-    if (!ANCHOR_SHAPES.includes(stringValue as PadOptionsAnchorShape)) {
-      throw new Error(
-        `pad options anchor must be one of ${ANCHOR_SHAPES.join(", ")}`,
-      )
-    }
-    return new PadOptionsAnchor(stringValue as PadOptionsAnchorShape)
-  }
-
-  get shape(): PadOptionsAnchorShape {
-    return this._shape
-  }
-
-  set shape(value: PadOptionsAnchorShape) {
-    this._shape = value
-  }
-
-  override getChildren(): SxClass[] {
-    return []
-  }
-
-  override getString(): string {
-    return `(anchor ${this._shape})`
-  }
-}
-SxClass.register(PadOptionsAnchor)

package/lib/sexpr/classes/PadPinFunction.ts

@@ -1,9 +0,0 @@
-import { SxPrimitiveString } from "../base-classes/SxPrimitiveString"
-import { SxClass } from "../base-classes/SxClass"
-
-export class PadPinFunction extends SxPrimitiveString {
-  static override token = "pinfunction"
-  static override parentToken = "pad"
-  token = "pinfunction"
-}
-SxClass.register(PadPinFunction)

package/lib/sexpr/classes/PadPinType.ts

@@ -1,9 +0,0 @@
-import { SxPrimitiveString } from "../base-classes/SxPrimitiveString"
-import { SxClass } from "../base-classes/SxClass"
-
-export class PadPinType extends SxPrimitiveString {
-  static override token = "pintype"
-  static override parentToken = "pad"
-  token = "pintype"
-}
-SxClass.register(PadPinType)

package/lib/sexpr/classes/PadPrimitiveGrArc.ts

@@ -1,272 +0,0 @@
-import { SxClass } from "../base-classes/SxClass"
-import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
-import { Width } from "./Width"
-import { toNumberValue } from "../utils/toNumberValue"
-
-const SUPPORTED_TOKENS = new Set(["start", "mid", "end", "width"])
-
-export interface PadPrimitiveGrArcConstructorParams {
-  start?: PadPrimitiveGrArcStart | { x: number; y: number }
-  mid?: PadPrimitiveGrArcMid | { x: number; y: number }
-  end?: PadPrimitiveGrArcEnd | { x: number; y: number }
-  width?: Width | number
-}
-
-export class PadPrimitiveGrArc extends SxClass {
-  static override token = "gr_arc"
-  static override parentToken = "primitives"
-  override token = "gr_arc"
-
-  private _sxStart?: PadPrimitiveGrArcStart
-  private _sxMid?: PadPrimitiveGrArcMid
-  private _sxEnd?: PadPrimitiveGrArcEnd
-  private _sxWidth?: Width
-
-  constructor(params: PadPrimitiveGrArcConstructorParams = {}) {
-    super()
-    if (params.start !== undefined) this.start = params.start
-    if (params.mid !== undefined) this.mid = params.mid
-    if (params.end !== undefined) this.end = params.end
-    if (params.width !== undefined) this.width = params.width
-  }
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): PadPrimitiveGrArc {
-    const arc = new PadPrimitiveGrArc()
-
-    const { propertyMap, arrayPropertyMap } =
-      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
-
-    for (const token of Object.keys(propertyMap)) {
-      if (!SUPPORTED_TOKENS.has(token)) {
-        throw new Error(
-          `pad primitive gr_arc encountered unsupported child token "${token}"`,
-        )
-      }
-    }
-
-    for (const [token, entries] of Object.entries(arrayPropertyMap)) {
-      if (!SUPPORTED_TOKENS.has(token)) {
-        throw new Error(
-          `pad primitive gr_arc encountered unsupported child token "${token}"`,
-        )
-      }
-      if (entries.length > 1) {
-        throw new Error(
-          `pad primitive gr_arc does not support repeated "${token}" tokens`,
-        )
-      }
-    }
-
-    arc._sxStart = propertyMap.start as PadPrimitiveGrArcStart | undefined
-    arc._sxMid = propertyMap.mid as PadPrimitiveGrArcMid | undefined
-    arc._sxEnd = propertyMap.end as PadPrimitiveGrArcEnd | undefined
-    arc._sxWidth = propertyMap.width as Width | undefined
-
-    if (!arc._sxStart) {
-      throw new Error("pad primitive gr_arc requires a start child token")
-    }
-    if (!arc._sxMid) {
-      throw new Error("pad primitive gr_arc requires a mid child token")
-    }
-    if (!arc._sxEnd) {
-      throw new Error("pad primitive gr_arc requires an end child token")
-    }
-
-    return arc
-  }
-
-  get start(): PadPrimitiveGrArcStart | undefined {
-    return this._sxStart
-  }
-
-  set start(value:
-    | PadPrimitiveGrArcStart
-    | { x: number; y: number }
-    | undefined,) {
-    this._sxStart = normalizeArcPoint(value, PadPrimitiveGrArcStart)
-  }
-
-  get mid(): PadPrimitiveGrArcMid | undefined {
-    return this._sxMid
-  }
-
-  set mid(value: PadPrimitiveGrArcMid | { x: number; y: number } | undefined) {
-    this._sxMid = normalizeArcPoint(value, PadPrimitiveGrArcMid)
-  }
-
-  get end(): PadPrimitiveGrArcEnd | undefined {
-    return this._sxEnd
-  }
-
-  set end(value: PadPrimitiveGrArcEnd | { x: number; y: number } | undefined) {
-    this._sxEnd = normalizeArcPoint(value, PadPrimitiveGrArcEnd)
-  }
-
-  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
-  }
-
-  override getChildren(): SxClass[] {
-    const children: SxClass[] = []
-    if (this._sxStart) children.push(this._sxStart)
-    if (this._sxMid) children.push(this._sxMid)
-    if (this._sxEnd) children.push(this._sxEnd)
-    if (this._sxWidth) children.push(this._sxWidth)
-    return children
-  }
-
-  override getString(): string {
-    const lines = ["(gr_arc"]
-    if (this._sxStart) lines.push(this._sxStart.getStringIndented())
-    if (this._sxMid) lines.push(this._sxMid.getStringIndented())
-    if (this._sxEnd) lines.push(this._sxEnd.getStringIndented())
-    if (this._sxWidth) lines.push(this._sxWidth.getStringIndented())
-    lines.push(")")
-    return lines.join("\n")
-  }
-}
-SxClass.register(PadPrimitiveGrArc)
-
-type ArcPointConstructor<T extends PadPrimitiveGrArcPoint> = new (
-  x: number,
-  y: number,
-) => T
-
-const normalizeArcPoint = <T extends PadPrimitiveGrArcPoint>(
-  value: T | { x: number; y: number } | undefined,
-  Constructor: ArcPointConstructor<T>,
-): T | undefined => {
-  if (value === undefined) {
-    return undefined
-  }
-  if (value instanceof Constructor) {
-    return value
-  }
-  return new Constructor(value.x, value.y)
-}
-
-abstract class PadPrimitiveGrArcPoint extends SxClass {
-  protected _x: number
-  protected _y: number
-
-  protected constructor(x: number, y: number) {
-    super()
-    this._x = x
-    this._y = 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
-  }
-
-  override getChildren(): SxClass[] {
-    return []
-  }
-
-  override getString(): string {
-    return `(${this.token} ${this._x} ${this._y})`
-  }
-}
-
-class PadPrimitiveGrArcStart extends PadPrimitiveGrArcPoint {
-  static override token = "start"
-  static override parentToken = "gr_arc"
-  override token = "start"
-
-  constructor(x: number, y: number) {
-    super(x, y)
-  }
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): PadPrimitiveGrArcStart {
-    const [rawX, rawY] = primitiveSexprs
-    const x = toNumberValue(rawX)
-    const y = toNumberValue(rawY)
-
-    if (x === undefined || y === undefined) {
-      throw new Error(
-        "pad primitive gr_arc start expects two numeric arguments",
-      )
-    }
-
-    return new PadPrimitiveGrArcStart(x, y)
-  }
-}
-SxClass.register(PadPrimitiveGrArcStart)
-
-class PadPrimitiveGrArcMid extends PadPrimitiveGrArcPoint {
-  static override token = "mid"
-  static override parentToken = "gr_arc"
-  override token = "mid"
-
-  constructor(x: number, y: number) {
-    super(x, y)
-  }
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): PadPrimitiveGrArcMid {
-    const [rawX, rawY] = primitiveSexprs
-    const x = toNumberValue(rawX)
-    const y = toNumberValue(rawY)
-
-    if (x === undefined || y === undefined) {
-      throw new Error("pad primitive gr_arc mid expects two numeric arguments")
-    }
-
-    return new PadPrimitiveGrArcMid(x, y)
-  }
-}
-SxClass.register(PadPrimitiveGrArcMid)
-
-class PadPrimitiveGrArcEnd extends PadPrimitiveGrArcPoint {
-  static override token = "end"
-  static override parentToken = "gr_arc"
-  override token = "end"
-
-  constructor(x: number, y: number) {
-    super(x, y)
-  }
-
-  static override fromSexprPrimitives(
-    primitiveSexprs: PrimitiveSExpr[],
-  ): PadPrimitiveGrArcEnd {
-    const [rawX, rawY] = primitiveSexprs
-    const x = toNumberValue(rawX)
-    const y = toNumberValue(rawY)
-
-    if (x === undefined || y === undefined) {
-      throw new Error("pad primitive gr_arc end expects two numeric arguments")
-    }
-
-    return new PadPrimitiveGrArcEnd(x, y)
-  }
-}
-SxClass.register(PadPrimitiveGrArcEnd)