kicadts 0.0.1

package/lib/sexpr/classes/ViaNet.ts

@@ -0,0 +1,59 @@
+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 ViaNet extends SxClass {
+  static override token = "net"
+  static override parentToken = "via"
+  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[],
+  ): ViaNet {
+    const id = toNumberValue(primitiveSexprs[0])
+    if (id === undefined) {
+      throw new Error("via net requires a numeric id")
+    }
+    const name = primitiveSexprs.length > 1 ? toStringValue(primitiveSexprs[1]) : undefined
+    return new ViaNet(id, name)
+  }
+
+  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
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    if (this._name !== undefined) {
+      return `(net ${this._id} ${quoteSExprString(this._name)})`
+    }
+    return `(net ${this._id})`
+  }
+}
+SxClass.register(ViaNet)

package/lib/sexpr/classes/Width.ts

@@ -0,0 +1,8 @@
+import { SxClass } from "../base-classes/SxClass"
+import { SxPrimitiveNumber } from "../base-classes/SxPrimitiveNumber"
+
+export class Width extends SxPrimitiveNumber {
+  static override token = "width"
+  token = "width"
+}
+SxClass.register(Width)

package/lib/sexpr/classes/Wire.ts

@@ -0,0 +1,91 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { Pts } from "./Pts"
+import { Stroke } from "./Stroke"
+import { Uuid } from "./Uuid"
+
+const SUPPORTED_TOKENS = new Set(["pts", "stroke", "uuid"])
+
+export class Wire extends SxClass {
+  static override token = "wire"
+  static override parentToken = "kicad_sch"
+  override token = "wire"
+
+  private _sxPts?: Pts
+  private _sxStroke?: Stroke
+  private _sxUuid?: Uuid
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Wire {
+    const wire = new Wire()
+
+    const { propertyMap, arrayPropertyMap } =
+      SxClass.parsePrimitivesToClassProperties(primitiveSexprs, this.token)
+
+    for (const [token, entries] of Object.entries(arrayPropertyMap)) {
+      if (!SUPPORTED_TOKENS.has(token)) {
+        throw new Error(
+          `Unsupported child tokens inside wire expression: ${token}`,
+        )
+      }
+      if (entries.length > 1) {
+        throw new Error(`wire does not support repeated child tokens: ${token}`)
+      }
+    }
+
+    const unsupportedTokens = Object.keys(propertyMap).filter(
+      (token) => !SUPPORTED_TOKENS.has(token),
+    )
+    if (unsupportedTokens.length > 0) {
+      throw new Error(
+        `Unsupported child tokens inside wire expression: ${unsupportedTokens.join(", ")}`,
+      )
+    }
+
+    wire._sxPts =
+      (arrayPropertyMap.pts?.[0] as Pts | undefined) ??
+      (propertyMap.pts as Pts | undefined)
+    wire._sxStroke = propertyMap.stroke as Stroke | undefined
+    wire._sxUuid = propertyMap.uuid as Uuid | undefined
+
+    return wire
+  }
+
+  get points(): Pts | undefined {
+    return this._sxPts
+  }
+
+  set points(value: Pts | undefined) {
+    this._sxPts = value
+  }
+
+  get stroke(): Stroke | undefined {
+    return this._sxStroke
+  }
+
+  set stroke(value: Stroke | undefined) {
+    this._sxStroke = 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._sxPts) children.push(this._sxPts)
+    if (this._sxStroke) children.push(this._sxStroke)
+    if (this._sxUuid) children.push(this._sxUuid)
+    return children
+  }
+}
+SxClass.register(Wire)

package/lib/sexpr/classes/Xy.ts

@@ -0,0 +1,35 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { toNumberValue } from "../utils/toNumberValue"
+
+export class Xy extends SxClass {
+  static override token = "xy"
+  token = "xy"
+
+  x: number
+  y: number
+
+  constructor(x: number, y: number) {
+    super()
+    this.x = x
+    this.y = y
+  }
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Xy {
+    const [rawX, rawY] = primitiveSexprs
+    const x = toNumberValue(rawX) ?? 0
+    const y = toNumberValue(rawY) ?? 0
+    return new Xy(x, y)
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    return `(xy ${this.x} ${this.y})`
+  }
+}
+SxClass.register(Xy)

package/lib/sexpr/classes/Zone.ts

@@ -0,0 +1,41 @@
+import { SxClass } from "../base-classes/SxClass"
+import { printSExpr, type PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+
+export class Zone extends SxClass {
+  static override token = "zone"
+  token = "zone"
+
+  private _rawChildren: PrimitiveSExpr[] = []
+
+  static override fromSexprPrimitives(
+    primitiveSexprs: PrimitiveSExpr[],
+  ): Zone {
+    const zone = new Zone()
+    zone._rawChildren = [...primitiveSexprs]
+    return zone
+  }
+
+  get rawChildren(): PrimitiveSExpr[] {
+    return [...this._rawChildren]
+  }
+
+  set rawChildren(children: PrimitiveSExpr[]) {
+    this._rawChildren = [...children]
+  }
+
+  override getChildren(): SxClass[] {
+    return []
+  }
+
+  override getString(): string {
+    const lines = ["(zone"]
+
+    for (const arg of this._rawChildren) {
+      lines.push(`  ${printSExpr(arg)}`)
+    }
+
+    lines.push(")")
+    return lines.join("\n")
+  }
+}
+SxClass.register(Zone)

package/lib/sexpr/index.ts

@@ -0,0 +1,130 @@
+export * from "./base-classes/SxClass"
+export * from "./classes/Stroke"
+export * from "./classes/Width"
+export * from "./classes/Unit"
+export * from "./classes/InBom"
+export * from "./classes/OnBoard"
+export * from "./classes/StrokeType"
+export * from "./classes/Color"
+export * from "./classes/Pts"
+export * from "./classes/At"
+export * from "./classes/Xy"
+export * from "./classes/TextEffects"
+export * from "./classes/TitleBlock"
+export * from "./classes/Paper"
+export * from "./classes/Image"
+export * from "./classes/RenderCache"
+export * from "./classes/Uuid"
+export * from "./classes/KicadSchGenerator"
+export * from "./classes/KicadSchVersion"
+export * from "./classes/KicadSchGeneratorVersion"
+export * from "./classes/LibSymbols"
+export * from "./classes/Wire"
+export * from "./classes/Bus"
+export * from "./classes/Junction"
+export * from "./classes/NoConnect"
+export * from "./classes/BusEntry"
+export * from "./classes/Label"
+export * from "./classes/SchematicText"
+export * from "./classes/KicadSch"
+export * from "./classes/Property"
+export * from "./classes/PropertyUnlocked"
+export * from "./classes/PropertyHide"
+export * from "./classes/Footprint"
+export * from "./classes/FootprintLocked"
+export * from "./classes/FootprintPlaced"
+export * from "./classes/FootprintTedit"
+export * from "./classes/FootprintDescr"
+export * from "./classes/FootprintTags"
+export * from "./classes/FootprintSheetname"
+export * from "./classes/FootprintSheetfile"
+export * from "./classes/FootprintPath"
+export * from "./classes/FootprintAutoplaceCost90"
+export * from "./classes/FootprintAutoplaceCost180"
+export * from "./classes/FootprintSolderMaskMargin"
+export * from "./classes/FootprintSolderPasteMargin"
+export * from "./classes/FootprintSolderPasteRatio"
+export * from "./classes/FootprintClearance"
+export * from "./classes/FootprintZoneConnect"
+export * from "./classes/FootprintThermalWidth"
+export * from "./classes/FootprintThermalGap"
+export * from "./classes/FootprintAttr"
+export * from "./classes/FootprintPrivateLayers"
+export * from "./classes/FootprintNetTiePadGroups"
+export * from "./classes/GrLine"
+export * from "./classes/GrLineStart"
+export * from "./classes/GrLineEnd"
+export * from "./classes/GrLineAngle"
+export * from "./classes/GrLineLocked"
+export * from "./classes/GrText"
+export * from "./classes/Segment"
+export * from "./classes/SegmentStart"
+export * from "./classes/SegmentEnd"
+export * from "./classes/SegmentNet"
+export * from "./classes/SegmentLocked"
+export * from "./classes/Zone"
+export * from "./classes/EmbeddedFonts"
+export * from "./classes/Layers"
+export * from "./classes/Layer"
+export * from "./classes/FpText"
+export * from "./classes/FpTextBox"
+export * from "./classes/FpLine"
+export * from "./classes/FpRect"
+export * from "./classes/FpCircle"
+export * from "./classes/FpArc"
+export * from "./classes/FpPoly"
+export * from "./classes/FpPolyFill"
+export * from "./classes/FpPolyLocked"
+export * from "./classes/FootprintPad"
+export * from "./classes/FootprintModel"
+export * from "./classes/PadSize"
+export * from "./classes/PadDrill"
+export * from "./classes/PadDrillOffset"
+export * from "./classes/PadLayers"
+export * from "./classes/PadRoundrectRratio"
+export * from "./classes/PadRectDelta"
+export * from "./classes/PadChamferRatio"
+export * from "./classes/PadChamfer"
+export * from "./classes/PadNet"
+export * from "./classes/PadPinFunction"
+export * from "./classes/PadPinType"
+export * from "./classes/PadDieLength"
+export * from "./classes/PadSolderMaskMargin"
+export * from "./classes/PadSolderPasteMargin"
+export * from "./classes/PadSolderPasteMarginRatio"
+export * from "./classes/PadClearance"
+export * from "./classes/PadZoneConnect"
+export * from "./classes/PadThermalWidth"
+export * from "./classes/PadThermalGap"
+export * from "./classes/PadThermalBridgeAngle"
+export * from "./classes/PadOptions"
+export * from "./classes/PadPrimitives"
+export * from "./classes/PadPrimitiveGrLine"
+export * from "./classes/PadPrimitiveGrArc"
+export * from "./classes/PadPrimitiveGrCircle"
+export * from "./classes/PadTeardrops"
+export * from "./classes/Symbol"
+export * from "./classes/Sheet"
+export * from "./classes/SheetPin"
+export * from "./classes/SheetProperty"
+export * from "./classes/SheetInstances"
+export * from "./classes/SheetInstancesRoot"
+export * from "./classes/SheetFill"
+export * from "./classes/SheetSize"
+export * from "./classes/FieldsAutoplaced"
+export * from "./classes/ExcludeFromSim"
+export * from "./classes/Dnp"
+export * from "./classes/Setup"
+export * from "./classes/PcbGeneral"
+export * from "./classes/PcbGeneralThickness"
+export * from "./classes/PcbGeneralLegacyTeardrops"
+export * from "./classes/PcbLayers"
+export * from "./classes/PcbLayerDefinition"
+export * from "./classes/PcbNet"
+export * from "./classes/PcbVersion"
+export * from "./classes/PcbGenerator"
+export * from "./classes/PcbGeneratorVersion"
+export * from "./classes/KicadPcb"
+export * from "./classes/Via"
+export * from "./classes/ViaNet"
+export * from "./parseKicadSexpr"

package/lib/sexpr/parseKicadSexpr.ts

@@ -0,0 +1,5 @@
+import { SxClass } from "./base-classes/SxClass"
+
+export const parseKicadSexpr = (sexpr: string) => {
+  return SxClass.parse(sexpr)
+}

package/lib/sexpr/parseToPrimitiveSExpr.ts

@@ -0,0 +1,240 @@
+// s_expr_parser.ts
+export type PrimitiveSExpr =
+  | string // symbols and string literals (distinct via `type` guard if you want)
+  | number
+  | boolean
+  | null
+  | PrimitiveSExpr[] // lists
+
+type Token =
+  | { type: "lparen" }
+  | { type: "rparen" }
+  | { type: "number"; value: number }
+  | { type: "string"; value: string }
+  | { type: "boolean"; value: boolean }
+  | { type: "nil" }
+  | { type: "symbol"; value: string }
+
+export function tokenize(input: string): Token[] {
+  const tokens: Token[] = []
+  let i = 0
+
+  const isWhitespace = (ch: string) => /\s/.test(ch)
+  const isSymbolInitial = (ch: string) => /[^\s()"]/u.test(ch) // anything except ws, parens, quote
+  const peek = () => (i < input.length ? input[i]! : undefined)
+  const advance = () => {
+    if (i >= input.length) {
+      throw new SyntaxError("Unexpected end of input")
+    }
+    return input[i++]!
+  }
+
+  while (i < input.length) {
+    const ch = peek()
+    if (ch === undefined) {
+      break
+    }
+    const current: string = ch
+
+    // Skip whitespace
+    if (isWhitespace(current)) {
+      i++
+      continue
+    }
+
+    // Comments ;...<EOL>
+    if (current === ";") {
+      while (i < input.length && input[i] !== "\n") i++
+      continue
+    }
+
+    if (current === "(") {
+      tokens.push({ type: "lparen" })
+      i++
+      continue
+    }
+    if (current === ")") {
+      tokens.push({ type: "rparen" })
+      i++
+      continue
+    }
+
+    // String literal
+    if (current === '"') {
+      i++ // skip opening quote
+      let out = ""
+      while (i < input.length) {
+        const c = advance()
+        if (c === '"') break
+        if (c === "\\") {
+          if (i >= input.length)
+            throw new SyntaxError("Unterminated escape in string")
+          const e = advance()
+          switch (e) {
+            case "n":
+              out += "\n"
+              break
+            case "r":
+              out += "\r"
+              break
+            case "t":
+              out += "\t"
+              break
+            case '"':
+              out += '"'
+              break
+            case "\\":
+              out += "\\"
+              break
+            default:
+              out += e
+              break // unknown escapes: keep raw
+          }
+        } else {
+          out += c
+        }
+      }
+      if (input[i - 1] !== '"')
+        throw new SyntaxError("Unterminated string literal")
+      tokens.push({ type: "string", value: out })
+      continue
+    }
+
+    // Number or symbol
+    if (isSymbolInitial(current) || current === "-" || current === "+" || current === ".") {
+      // read a maximal token until delimiter
+      let start = i
+      while (i < input.length) {
+        const nextChar = input[i]!
+        if (
+          isWhitespace(nextChar) ||
+          nextChar === "(" ||
+          nextChar === ")" ||
+          nextChar === '"'
+        ) {
+          break
+        }
+        i++
+      }
+      const raw = input.slice(start, i)
+
+      // Booleans
+      if (raw === "#t") {
+        tokens.push({ type: "boolean", value: true })
+        continue
+      }
+      if (raw === "#f") {
+        tokens.push({ type: "boolean", value: false })
+        continue
+      }
+
+      // nil
+      if (raw === "nil") {
+        tokens.push({ type: "nil" })
+        continue
+      }
+
+      // Numbers (int/float), allow leading +/-, decimals, exponent
+      if (/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/u.test(raw)) {
+        tokens.push({ type: "number", value: Number(raw) })
+      } else {
+        tokens.push({ type: "symbol", value: raw })
+      }
+      continue
+    }
+
+    throw new SyntaxError(`Unexpected character: ${JSON.stringify(ch)} at ${i}`)
+  }
+
+  return tokens
+}
+
+export function parseToPrimitiveSExpr(input: string): PrimitiveSExpr[] {
+  const toks = tokenize(input)
+  let idx = 0
+
+  const peekToken = () => (idx < toks.length ? toks[idx]! : undefined)
+  const advanceToken = () => {
+    if (idx >= toks.length) {
+      throw new SyntaxError("Unexpected end of input")
+    }
+    return toks[idx++]!
+  }
+
+  function readForm(): PrimitiveSExpr {
+    const t = advanceToken()
+
+    switch (t.type) {
+      case "lparen": {
+        const list: PrimitiveSExpr[] = []
+        while (true) {
+          const next = peekToken()
+          if (!next) {
+            throw new SyntaxError("Unmatched '('")
+          }
+          if (next.type === "rparen") break
+          list.push(readForm())
+        }
+        advanceToken() // consume rparen
+        return list
+      }
+      case "rparen":
+        throw new SyntaxError("Unmatched ')'")
+      case "number":
+        return t.value
+      case "string":
+        return t.value
+      case "boolean":
+        return t.value
+      case "nil":
+        return null
+      case "symbol":
+        return t.value // represent symbols as strings
+    }
+  }
+
+  const forms: PrimitiveSExpr[] = []
+  while (peekToken()) forms.push(readForm())
+  return forms
+}
+
+/* -------------------------
+   Tiny helper utilities
+--------------------------*/
+
+export function printSExpr(x: PrimitiveSExpr): string {
+  if (x === null) return "nil"
+  if (typeof x === "boolean") return x ? "#t" : "#f"
+  if (typeof x === "number") return Number.isFinite(x) ? String(x) : "nan"
+  if (typeof x === "string") {
+    // naive: treat as symbol if it looks like a symbol; otherwise quote
+    if (/^[^\s()"]+$/u.test(x) && x !== "nil" && x !== "#t" && x !== "#f")
+      return x
+    return `"${x.replace(/["\\\n\r\t]/g, (m) =>
+      m === '"'
+        ? '\\"'
+        : m === "\\"
+          ? "\\\\"
+          : m === "\n"
+            ? "\\n"
+            : m === "\r"
+              ? "\\r"
+              : "\\t",
+    )}"`
+  }
+  if (Array.isArray(x)) {
+    return `(${x.map(printSExpr).join(" ")})`
+  }
+
+  throw new Error(`Unsupported S-expression value: ${JSON.stringify(x)}`)
+}
+
+// Quick example:
+// const program = `
+//   ; define square
+//   (define (square x) (* x x))
+//   (list 1 2.5 "hi" #t nil foo-bar)
+// `;
+// const ast = parseSExpr(program);
+// console.log(JSON.stringify(ast, null, 2));
+// console.log(ast.map(printSExpr).join("\n"));

package/lib/sexpr/utils/indentLines.ts

@@ -0,0 +1,3 @@
+export const indentLines = (value: string, indent = "  "): string[] => {
+  return value.split("\n").map((line) => `${indent}${line}`)
+}

package/lib/sexpr/utils/parseYesNo.ts

@@ -0,0 +1,12 @@
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { toStringValue } from "./toStringValue"
+
+export const parseYesNo = (
+  value: PrimitiveSExpr | undefined,
+): boolean | undefined => {
+  const str = toStringValue(value)
+  if (!str) return undefined
+  if (str === "yes" || str === "true") return true
+  if (str === "no" || str === "false") return false
+  return undefined
+}

package/lib/sexpr/utils/quoteSExprString.ts

@@ -0,0 +1,8 @@
+export const quoteSExprString = (value: string): string => {
+  return `"${value
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, "\\n")
+    .replace(/\r/g, "\\r")
+    .replace(/\t/g, "\\t")}"`
+}

package/lib/sexpr/utils/strokeFromArgs.ts

@@ -0,0 +1,19 @@
+import { SxClass } from "../base-classes/SxClass"
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+import { Stroke } from "../classes/Stroke"
+
+export const strokeFromArgs = (
+  args: PrimitiveSExpr[],
+): Stroke | undefined => {
+  try {
+    const parsed = SxClass.parsePrimitiveSexpr(
+      ["stroke", ...args] as PrimitiveSExpr,
+    )
+    if (parsed instanceof Stroke) {
+      return parsed
+    }
+  } catch {
+    // Ignore parse errors and defer to caller
+  }
+  return undefined
+}

package/lib/sexpr/utils/toNumberValue.ts

@@ -0,0 +1,13 @@
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+
+export const toNumberValue = (
+  value: PrimitiveSExpr | undefined,
+): number | undefined => {
+  if (value === undefined) return undefined
+  if (typeof value === "number") return value
+  if (typeof value === "string") {
+    const parsed = Number(value)
+    return Number.isNaN(parsed) ? undefined : parsed
+  }
+  return undefined
+}

package/lib/sexpr/utils/toStringValue.ts

@@ -0,0 +1,10 @@
+import type { PrimitiveSExpr } from "../parseToPrimitiveSExpr"
+
+export const toStringValue = (
+  value: PrimitiveSExpr | undefined,
+): string | undefined => {
+  if (value === undefined) return undefined
+  if (typeof value === "string") return value
+  if (typeof value === "number" || typeof value === "boolean") return String(value)
+  return undefined
+}