kicadts 0.0.1

package/lib/sexpr/classes/Setup/Stackup.ts

@@ -0,0 +1,140 @@
+import { SxClass } from "../../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../../parseToPrimitiveSExpr"
+
+import {
+  StackupCastellatedPads,
+  StackupCopperFinish,
+  StackupDielectricConstraints,
+  StackupEdgeConnector,
+  StackupEdgePlating,
+} from "./StackupProperties"
+import { StackupLayer } from "./StackupLayer"
+
+export class Stackup extends SxClass {
+  static override token = "stackup"
+  static override parentToken = "setup"
+  token = "stackup"
+
+  private _layers: StackupLayer[] = []
+  private _sxCopperFinish?: StackupCopperFinish
+  private _sxDielectricConstraints?: StackupDielectricConstraints
+  private _sxEdgeConnector?: StackupEdgeConnector
+  private _sxCastellatedPads?: StackupCastellatedPads
+  private _sxEdgePlating?: StackupEdgePlating
+
+  constructor(opts: {
+    layers?: StackupLayer[]
+    copperFinish?: StackupCopperFinish
+    dielectricConstraints?: StackupDielectricConstraints
+    edgeConnector?: StackupEdgeConnector
+    castellatedPads?: StackupCastellatedPads
+    edgePlating?: StackupEdgePlating
+  } = {}) {
+    super()
+    this.layers = opts.layers ?? []
+    this._sxCopperFinish = opts.copperFinish
+    this._sxDielectricConstraints = opts.dielectricConstraints
+    this._sxEdgeConnector = opts.edgeConnector
+    this._sxCastellatedPads = opts.castellatedPads
+    this._sxEdgePlating = opts.edgePlating
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Stackup {
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
+
+    return new Stackup({
+      layers: (arrayPropertyMap.layer as StackupLayer[] | undefined) ?? [],
+      copperFinish: propertyMap.copper_finish as StackupCopperFinish,
+      dielectricConstraints:
+        propertyMap.dielectric_constraints as StackupDielectricConstraints,
+      edgeConnector: propertyMap.edge_connector as StackupEdgeConnector,
+      castellatedPads:
+        propertyMap.castellated_pads as StackupCastellatedPads,
+      edgePlating: propertyMap.edge_plating as StackupEdgePlating,
+    })
+  }
+
+  get layers(): StackupLayer[] {
+    return [...this._layers]
+  }
+
+  set layers(layers: StackupLayer[]) {
+    this._layers = layers.map((layer) => {
+      if (!(layer instanceof StackupLayer)) {
+        throw new Error("Stackup layers must be StackupLayer instances")
+      }
+      return layer
+    })
+  }
+
+  get copperFinish(): string | undefined {
+    return this._sxCopperFinish?.value
+  }
+
+  set copperFinish(value: string | undefined) {
+    this._sxCopperFinish = value
+      ? new StackupCopperFinish(value)
+      : undefined
+  }
+
+  get dielectricConstraints(): string | undefined {
+    return this._sxDielectricConstraints?.value
+  }
+
+  set dielectricConstraints(value: string | undefined) {
+    this._sxDielectricConstraints = value
+      ? new StackupDielectricConstraints(value)
+      : undefined
+  }
+
+  get edgeConnector(): string | undefined {
+    return this._sxEdgeConnector?.value
+  }
+
+  set edgeConnector(value: string | undefined) {
+    this._sxEdgeConnector = value
+      ? new StackupEdgeConnector(value)
+      : undefined
+  }
+
+  get castellatedPads(): string | undefined {
+    return this._sxCastellatedPads?.value
+  }
+
+  set castellatedPads(value: string | undefined) {
+    this._sxCastellatedPads = value
+      ? new StackupCastellatedPads(value)
+      : undefined
+  }
+
+  get edgePlating(): string | undefined {
+    return this._sxEdgePlating?.value
+  }
+
+  set edgePlating(value: string | undefined) {
+    this._sxEdgePlating = value
+      ? new StackupEdgePlating(value)
+      : undefined
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = [...this._layers]
+    const optionalChildren = [
+      this._sxCopperFinish,
+      this._sxDielectricConstraints,
+      this._sxEdgeConnector,
+      this._sxCastellatedPads,
+      this._sxEdgePlating,
+    ]
+    for (const child of optionalChildren) {
+      if (child) {
+        children.push(child)
+      }
+    }
+    return children
+  }
+}
+SxClass.register(Stackup)

package/lib/sexpr/classes/Setup/StackupLayer.ts

@@ -0,0 +1,233 @@
+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 {
+  StackupLayerColor,
+  StackupLayerEpsilonR,
+  StackupLayerLossTangent,
+  StackupLayerMaterial,
+  StackupLayerThickness,
+  StackupLayerType,
+} from "./StackupLayerProperties"
+
+export class StackupLayer extends SxClass {
+  static override token = "layer"
+  static override parentToken = "stackup"
+  token = "layer"
+
+  private _name: string
+  private _number?: number
+
+  private _sxType?: StackupLayerType
+  private _sxColor?: StackupLayerColor
+  private _sxThickness?: StackupLayerThickness
+  private _sxMaterial?: StackupLayerMaterial
+  private _sxEpsilonR?: StackupLayerEpsilonR
+  private _sxLossTangent?: StackupLayerLossTangent
+
+  constructor(
+    name: string,
+    opts: {
+      number?: number
+      type?: StackupLayerType
+      color?: StackupLayerColor
+      thickness?: StackupLayerThickness
+      material?: StackupLayerMaterial
+      epsilonR?: StackupLayerEpsilonR
+      lossTangent?: StackupLayerLossTangent
+    } = {},
+  ) {
+    super()
+    this._name = name
+    this._number = opts.number
+    this._sxType = opts.type
+    this._sxColor = opts.color
+    this._sxThickness = opts.thickness
+    this._sxMaterial = opts.material
+    this._sxEpsilonR = opts.epsilonR
+    this._sxLossTangent = opts.lossTangent
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): StackupLayer {
+    if (primitiveSexprs.length === 0) {
+      throw new Error("Stackup layer requires at least a name")
+    }
+
+    const name = toStringValue(primitiveSexprs[0])
+    if (name === undefined) {
+      throw new Error("Stackup layer name must be a string")
+    }
+
+    let propertyIndex = 1
+    let number: number | undefined
+    const maybeNumber = primitiveSexprs[propertyIndex]
+    const numericLayerNumber = toNumberValue(maybeNumber)
+    if (numericLayerNumber !== undefined) {
+      number = numericLayerNumber
+      propertyIndex += 1
+    }
+
+    const propertyPrimitives = primitiveSexprs.slice(propertyIndex)
+    const { propertyMap } = SxClass.parsePrimitivesToClassProperties(
+      propertyPrimitives,
+      this.token,
+    )
+
+    return new StackupLayer(name, {
+      number,
+      type: propertyMap.type as StackupLayerType,
+      color: propertyMap.color as StackupLayerColor,
+      thickness: propertyMap.thickness as StackupLayerThickness,
+      material: propertyMap.material as StackupLayerMaterial,
+      epsilonR: propertyMap.epsilon_r as StackupLayerEpsilonR,
+      lossTangent: propertyMap.loss_tangent as StackupLayerLossTangent,
+    })
+  }
+
+  get name(): string {
+    return this._name
+  }
+
+  set name(value: string) {
+    const parsed = toStringValue(value)
+    if (parsed === undefined) {
+      throw new Error("Stackup layer name must be a string")
+    }
+    this._name = parsed
+  }
+
+  get number(): number | undefined {
+    return this._number
+  }
+
+  set number(value: number | undefined) {
+    if (value === undefined) {
+      this._number = undefined
+      return
+    }
+    const parsed = toNumberValue(value)
+    if (parsed === undefined) {
+      throw new Error("Stackup layer number must be numeric")
+    }
+    this._number = parsed
+  }
+
+  get type(): string | undefined {
+    return this._sxType?.value
+  }
+
+  set type(value: string | StackupLayerType | undefined) {
+    if (value === undefined) {
+      this._sxType = undefined
+      return
+    }
+    this._sxType =
+      value instanceof StackupLayerType ? value : new StackupLayerType(value)
+  }
+
+  get color(): string | undefined {
+    return this._sxColor?.value
+  }
+
+  set color(value: string | StackupLayerColor | undefined) {
+    if (value === undefined) {
+      this._sxColor = undefined
+      return
+    }
+    this._sxColor =
+      value instanceof StackupLayerColor ? value : new StackupLayerColor(value)
+  }
+
+  get thickness(): number | undefined {
+    return this._sxThickness?.value
+  }
+
+  set thickness(value: number | StackupLayerThickness | undefined) {
+    if (value === undefined) {
+      this._sxThickness = undefined
+      return
+    }
+    this._sxThickness =
+      value instanceof StackupLayerThickness
+        ? value
+        : new StackupLayerThickness(value)
+  }
+
+  get material(): string | undefined {
+    return this._sxMaterial?.value
+  }
+
+  set material(value: string | StackupLayerMaterial | undefined) {
+    if (value === undefined) {
+      this._sxMaterial = undefined
+      return
+    }
+    this._sxMaterial =
+      value instanceof StackupLayerMaterial
+        ? value
+        : new StackupLayerMaterial(value)
+  }
+
+  get epsilonR(): number | undefined {
+    return this._sxEpsilonR?.value
+  }
+
+  set epsilonR(value: number | StackupLayerEpsilonR | undefined) {
+    if (value === undefined) {
+      this._sxEpsilonR = undefined
+      return
+    }
+    this._sxEpsilonR =
+      value instanceof StackupLayerEpsilonR
+        ? value
+        : new StackupLayerEpsilonR(value)
+  }
+
+  get lossTangent(): number | undefined {
+    return this._sxLossTangent?.value
+  }
+
+  set lossTangent(value: number | StackupLayerLossTangent | undefined) {
+    if (value === undefined) {
+      this._sxLossTangent = undefined
+      return
+    }
+    this._sxLossTangent =
+      value instanceof StackupLayerLossTangent
+        ? value
+        : new StackupLayerLossTangent(value)
+  }
+
+  override getChildren(): SxClass[] {
+    const children: SxClass[] = []
+    if (this._sxType) children.push(this._sxType)
+    if (this._sxColor) children.push(this._sxColor)
+    if (this._sxThickness) children.push(this._sxThickness)
+    if (this._sxMaterial) children.push(this._sxMaterial)
+    if (this._sxEpsilonR) children.push(this._sxEpsilonR)
+    if (this._sxLossTangent) children.push(this._sxLossTangent)
+    return children
+  }
+
+  override getString(): string {
+    const header = `(layer ${quoteSExprString(this._name)}${
+      this._number !== undefined ? ` ${this._number}` : ""
+    }`
+    const children = this.getChildren()
+    if (children.length === 0) {
+      return `${header})`
+    }
+    const lines: string[] = [header]
+    for (const child of children) {
+      lines.push(child.getStringIndented())
+    }
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(StackupLayer)

package/lib/sexpr/classes/Setup/StackupLayerProperties.ts

@@ -0,0 +1,78 @@
+import { SxClass } from "../../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../../parseToPrimitiveSExpr"
+import { toNumberValue } from "../../utils/toNumberValue"
+
+import { SingleValueProperty } from "./base"
+
+abstract class StackupLayerProperty<T extends string | number> extends SingleValueProperty<T> {
+  static override parentToken = "layer"
+}
+
+export class StackupLayerType extends StackupLayerProperty<string> {
+  static override token = "type"
+  token = "type"
+  protected override quoteStringValue = true
+}
+SxClass.register(StackupLayerType)
+
+export class StackupLayerColor extends StackupLayerProperty<string> {
+  static override token = "color"
+  token = "color"
+  protected override quoteStringValue = true
+}
+SxClass.register(StackupLayerColor)
+
+export class StackupLayerThickness extends StackupLayerProperty<number> {
+  static override token = "thickness"
+  token = "thickness"
+
+  protected static override parsePrimitiveValue(
+    value: PrimitiveSExpr | undefined,
+  ): number {
+    const parsed = toNumberValue(value)
+    if (parsed === undefined) {
+      throw new Error("Stackup layer thickness expects a numeric value")
+    }
+    return parsed
+  }
+}
+SxClass.register(StackupLayerThickness)
+
+export class StackupLayerMaterial extends StackupLayerProperty<string> {
+  static override token = "material"
+  token = "material"
+  protected override quoteStringValue = true
+}
+SxClass.register(StackupLayerMaterial)
+
+export class StackupLayerEpsilonR extends StackupLayerProperty<number> {
+  static override token = "epsilon_r"
+  token = "epsilon_r"
+
+  protected static override parsePrimitiveValue(
+    value: PrimitiveSExpr | undefined,
+  ): number {
+    const parsed = toNumberValue(value)
+    if (parsed === undefined) {
+      throw new Error("Stackup layer epsilon_r expects a numeric value")
+    }
+    return parsed
+  }
+}
+SxClass.register(StackupLayerEpsilonR)
+
+export class StackupLayerLossTangent extends StackupLayerProperty<number> {
+  static override token = "loss_tangent"
+  token = "loss_tangent"
+
+  protected static override parsePrimitiveValue(
+    value: PrimitiveSExpr | undefined,
+  ): number {
+    const parsed = toNumberValue(value)
+    if (parsed === undefined) {
+      throw new Error("Stackup layer loss_tangent expects a numeric value")
+    }
+    return parsed
+  }
+}
+SxClass.register(StackupLayerLossTangent)

package/lib/sexpr/classes/Setup/StackupProperties.ts

@@ -0,0 +1,41 @@
+import { SxClass } from "../../base-classes/SxClass"
+
+import { SingleValueProperty } from "./base"
+
+abstract class StackupSingleValueProperty<
+  T extends string | number,
+> extends SingleValueProperty<T> {
+  static override parentToken = "stackup"
+}
+
+export class StackupCopperFinish extends StackupSingleValueProperty<string> {
+  static override token = "copper_finish"
+  token = "copper_finish"
+  protected override quoteStringValue = true
+}
+SxClass.register(StackupCopperFinish)
+
+export class StackupDielectricConstraints extends StackupSingleValueProperty<string> {
+  static override token = "dielectric_constraints"
+  token = "dielectric_constraints"
+}
+SxClass.register(StackupDielectricConstraints)
+
+export class StackupEdgeConnector extends StackupSingleValueProperty<string> {
+  static override token = "edge_connector"
+  token = "edge_connector"
+}
+SxClass.register(StackupEdgeConnector)
+
+export class StackupCastellatedPads extends StackupSingleValueProperty<string> {
+  static override token = "castellated_pads"
+  token = "castellated_pads"
+}
+SxClass.register(StackupCastellatedPads)
+
+export class StackupEdgePlating extends StackupSingleValueProperty<string> {
+  static override token = "edge_plating"
+  token = "edge_plating"
+}
+SxClass.register(StackupEdgePlating)
+

package/lib/sexpr/classes/Setup/base.ts

@@ -0,0 +1,167 @@
+import { SxClass } from "../../base-classes/SxClass"
+import { quoteSExprString } from "../../utils/quoteSExprString"
+import { toNumberValue } from "../../utils/toNumberValue"
+import { toStringValue } from "../../utils/toStringValue"
+import type { PrimitiveSExpr } from "../../parseToPrimitiveSExpr"
+
+type SingleValuePropertyConstructor<T extends string | number> = new (
+  value: T,
+) => SingleValueProperty<T>
+
+export abstract class SingleValueProperty<
+  T extends string | number,
+> extends SxClass {
+  protected _value: T
+  protected quoteStringValue = false
+
+  constructor(value: T) {
+    super()
+    this._value = value
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): SingleValueProperty<string | number> {
+    const [valuePrimitive] = primitiveSexprs
+    const value = (this as typeof SingleValueProperty).parsePrimitiveValue(
+      valuePrimitive,
+    )
+    const Constructor = this as unknown as SingleValuePropertyConstructor<
+      string | number
+    >
+    return new Constructor(value)
+  }
+
+  protected static parsePrimitiveValue(
+    value: PrimitiveSExpr | undefined,
+  ): string | number {
+    const stringValue = toStringValue(value)
+    if (stringValue === undefined) {
+      throw new Error(`${this.name} expects a primitive value`)
+    }
+    return stringValue
+  }
+
+  get value(): T {
+    return this._value
+  }
+
+  set value(value: T) {
+    this._value = value
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  protected formatValue(): string {
+    if (typeof this._value === "string") {
+      return this.quoteStringValue
+        ? quoteSExprString(this._value)
+        : this._value
+    }
+    return `${this._value}`
+  }
+
+  override getString(): string {
+    return `(${this.token} ${this.formatValue()})`
+  }
+}
+
+type NumericListPropertyConstructor = new (
+  values: number[],
+) => NumericListProperty
+
+export abstract class NumericListProperty extends SxClass {
+  protected _values: number[]
+
+  constructor(values: number[]) {
+    super()
+    this._values = values
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): NumericListProperty {
+    const values = primitiveSexprs.map((primitive) => {
+      const value = toNumberValue(primitive)
+      if (value === undefined) {
+        throw new Error(
+          `${this.name} expects numeric primitives but received ${primitive}`,
+        )
+      }
+      return value
+    })
+    const Constructor = this as unknown as NumericListPropertyConstructor
+    return new Constructor(values)
+  }
+
+  get values(): number[] {
+    return [...this._values]
+  }
+
+  set values(values: number[]) {
+    this._values = [...values]
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(${this.token} ${this._values.join(" ")})`
+  }
+}
+
+type CoordinatePropertyConstructor = new (
+  x: number,
+  y: number,
+) => CoordinateProperty
+
+export abstract class CoordinateProperty extends SxClass {
+  protected _x: number
+  protected _y: number
+
+  constructor(x: number, y: number) {
+    super()
+    this._x = x
+    this._y = y
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): CoordinateProperty {
+    const [xPrimitive, yPrimitive] = primitiveSexprs
+    const x = toNumberValue(xPrimitive)
+    const y = toNumberValue(yPrimitive)
+    if (x === undefined || y === undefined) {
+      throw new Error(`${this.name} expects two numeric values`)
+    }
+    const Constructor = this as unknown as CoordinatePropertyConstructor
+    return new Constructor(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
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(${this.token} ${this._x} ${this._y})`
+  }
+}

package/lib/sexpr/classes/Setup/index.ts

@@ -0,0 +1,14 @@
+export * from "./Setup"
+export * from "./Stackup"
+export * from "./StackupLayer"
+export * from "./StackupProperties"
+export * from "./StackupLayerProperties"
+export * from "./PcbPlotParams"
+export * from "./PcbPlotParamsBase"
+export * from "./PcbPlotParamsNumericProperties"
+export * from "./PcbPlotParamsStringPropertiesA"
+export * from "./PcbPlotParamsStringPropertiesB"
+export * from "./setupNumericProperties"
+export * from "./setupMultiValueProperties"
+export * from "./setupStringProperties"
+export * from "./SetupPropertyTypes"