kicadts 0.0.2 → 0.0.4

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

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

@@ -1,233 +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 {
-  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

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

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

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

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