circuit-json-to-kicad 0.0.28 → 0.0.30

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { CircuitJson } from 'circuit-json';
 import { CircuitJsonUtilObjects, cju } from '@tscircuit/circuit-json-util';
-import { KicadSch, KicadPcb } from 'kicadts';
+import { KicadSch, KicadPcb, SchematicSymbol } from 'kicadts';
 import { Matrix } from 'transformation-matrix';
 
 type PaperSize = "A0" | "A1" | "A2" | "A3" | "A4" | "A5";
@@ -17,6 +17,22 @@ interface PcbNetInfo {
     id: number;
     name: string;
 }
+interface SymbolEntry {
+    symbolName: string;
+    symbol: SchematicSymbol;
+}
+interface FootprintEntry {
+    footprintName: string;
+    kicadModString: string;
+    model3dSourcePaths: string[];
+}
+interface KicadLibraryOutput {
+    kicadSymString: string;
+    footprints: FootprintEntry[];
+    fpLibTableString: string;
+    symLibTableString: string;
+    model3dSourcePaths: string[];
+}
 interface ConverterContext {
     db: CircuitJsonUtilObjects;
     circuitJson: CircuitJson;
@@ -38,6 +54,13 @@ interface ConverterContext {
         y: number;
     }>;
     pcbNetMap?: Map<string, PcbNetInfo>;
+    libraryName?: string;
+    fpLibraryName?: string;
+    kicadSchString?: string;
+    kicadPcbString?: string;
+    symbolEntries?: SymbolEntry[];
+    footprintEntries?: FootprintEntry[];
+    libraryOutput?: KicadLibraryOutput;
 }
 declare abstract class ConverterStage<Input, Output> {
     MAX_ITERATIONS: number;
@@ -156,4 +179,26 @@ declare class CircuitJsonToKicadProConverter {
     getOutputString(): string;
 }
 
-export { CircuitJsonToKicadPcbConverter, CircuitJsonToKicadProConverter, CircuitJsonToKicadSchConverter };
+interface CircuitJsonToKicadLibraryOptions {
+    libraryName?: string;
+    footprintLibraryName?: string;
+}
+
+declare class CircuitJsonToKicadLibraryConverter {
+    ctx: ConverterContext;
+    pipeline: ConverterStage<CircuitJson, KicadLibraryOutput>[];
+    currentStageIndex: number;
+    finished: boolean;
+    get currentStage(): ConverterStage<CircuitJson, KicadLibraryOutput> | undefined;
+    constructor(circuitJson: CircuitJson, options?: CircuitJsonToKicadLibraryOptions);
+    step(): void;
+    runUntilFinished(): void;
+    getOutput(): KicadLibraryOutput;
+    getSymbolLibraryString(): string;
+    getFootprints(): FootprintEntry[];
+    getFpLibTableString(): string;
+    getSymLibTableString(): string;
+    getModel3dSourcePaths(): string[];
+}
+
+export { CircuitJsonToKicadLibraryConverter, CircuitJsonToKicadPcbConverter, CircuitJsonToKicadProConverter, CircuitJsonToKicadSchConverter, type FootprintEntry, type KicadLibraryOutput, type SymbolEntry };

package/dist/index.js

@@ -155,6 +155,7 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
     if (!symbolData) return null;
     const libId = getLibraryId(sourceComp, schematicComponent);
     const isChip = sourceComp.ftype === "simple_chip";
+    const footprintName = sourceComp.ftype || "";
     return this.createLibrarySymbol({
       libId,
       symbolData,
@@ -162,7 +163,8 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
       schematicComponent,
       description: this.getDescription(sourceComp),
       keywords: this.getKeywords(sourceComp),
-      fpFilters: this.getFpFilters(sourceComp)
+      fpFilters: this.getFpFilters(sourceComp),
+      footprintRef: footprintName ? `tscircuit:${footprintName}` : ""
     });
   }
   /**
@@ -244,7 +246,8 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
     schematicComponent,
     description,
     keywords,
-    fpFilters
+    fpFilters,
+    footprintRef = ""
   }) {
     const symbol = new SchematicSymbol({
       libraryId: libId,
@@ -263,7 +266,8 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
       libId,
       description,
       keywords,
-      fpFilters
+      fpFilters,
+      footprintRef
     });
     const drawingSymbol = this.createDrawingSubsymbol({
       libId,
@@ -289,7 +293,8 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
     libId,
     description,
     keywords,
-    fpFilters
+    fpFilters,
+    footprintRef = ""
   }) {
     const refPrefix = libId.split(":")[1]?.[0] || "U";
     const properties = [
@@ -303,7 +308,7 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
       { key: "Value", value: refPrefix, id: 1, at: [0, 0, 90], hide: false },
       {
         key: "Footprint",
-        value: "",
+        value: footprintRef,
         id: 2,
         at: [-1.778, 0, 90],
         hide: true
@@ -1398,7 +1403,7 @@ var AddNetsStage = class extends ConverterStage {
 };
 
 // lib/pcb/stages/AddFootprintsStage.ts
-import { Footprint } from "kicadts";
+import { Footprint, FootprintModel } from "kicadts";
 import { applyToPoint as applyToPoint9 } from "transformation-matrix";
 
 // lib/pcb/stages/utils/CreateSmdPadFromCircuitJson.ts
@@ -1781,6 +1786,44 @@ var AddFootprintsStage = class extends ConverterStage {
     if (!connectivityKey) return void 0;
     return this.ctx.pcbNetMap?.get(connectivityKey);
   }
+  /**
+   * Gets the cad_component associated with a pcb_component
+   */
+  getCadComponentForPcbComponent(pcbComponentId) {
+    const cadComponents = this.ctx.db.cad_component?.list() || [];
+    return cadComponents.find(
+      (cad) => cad.pcb_component_id === pcbComponentId
+    );
+  }
+  /**
+   * Creates FootprintModel instances from a cad_component's 3D model URLs
+   */
+  create3DModelsFromCadComponent(cadComponent, componentCenter) {
+    const models = [];
+    const modelUrl = cadComponent.model_step_url || cadComponent.model_wrl_url;
+    if (!modelUrl) return models;
+    const model = new FootprintModel(modelUrl);
+    if (cadComponent.position) {
+      model.offset = {
+        x: (cadComponent.position.x || 0) - componentCenter.x,
+        y: -((cadComponent.position.y || 0) - componentCenter.y),
+        z: cadComponent.position.z || 0
+      };
+    }
+    if (cadComponent.rotation) {
+      model.rotate = {
+        x: cadComponent.rotation.x || 0,
+        y: cadComponent.rotation.y || 0,
+        z: cadComponent.rotation.z || 0
+      };
+    }
+    if (cadComponent.model_unit_to_mm_scale_factor) {
+      const scale4 = cadComponent.model_unit_to_mm_scale_factor;
+      model.scale = { x: scale4, y: scale4, z: scale4 };
+    }
+    models.push(model);
+    return models;
+  }
   constructor(input, ctx) {
     super(input, ctx);
     this.pcbComponents = this.ctx.db.pcb_component.list();
@@ -1876,6 +1919,18 @@ var AddFootprintsStage = class extends ConverterStage {
       }
     }
     footprint.fpPads = fpPads;
+    const cadComponent = this.getCadComponentForPcbComponent(
+      component.pcb_component_id
+    );
+    if (cadComponent) {
+      const models = this.create3DModelsFromCadComponent(
+        cadComponent,
+        component.center
+      );
+      if (models.length > 0) {
+        footprint.models = models;
+      }
+    }
     const footprints = kicadPcb.footprints;
     footprints.push(footprint);
     kicadPcb.footprints = footprints;
@@ -2375,7 +2430,350 @@ var CircuitJsonToKicadProConverter = class {
 `;
   }
 };
+
+// lib/kicad-library/CircuitJsonToKicadLibraryConverter.ts
+import { cju as cju4 } from "@tscircuit/circuit-json-util";
+
+// lib/kicad-library/stages/GenerateKicadSchAndPcbStage.ts
+var GenerateKicadSchAndPcbStage = class extends ConverterStage {
+  _step() {
+    const schConverter = new CircuitJsonToKicadSchConverter(
+      this.ctx.circuitJson
+    );
+    schConverter.runUntilFinished();
+    this.ctx.kicadSchString = schConverter.getOutputString();
+    const pcbConverter = new CircuitJsonToKicadPcbConverter(
+      this.ctx.circuitJson
+    );
+    pcbConverter.runUntilFinished();
+    this.ctx.kicadPcbString = pcbConverter.getOutputString();
+    this.finished = true;
+  }
+  getOutput() {
+    return this.ctx.libraryOutput;
+  }
+};
+
+// lib/kicad-library/stages/ExtractSymbolsStage.ts
+import { parseKicadSexpr, KicadSch as KicadSch2 } from "kicadts";
+var ExtractSymbolsStage = class extends ConverterStage {
+  _step() {
+    const schContent = this.ctx.kicadSchString;
+    const fpLibraryName = this.ctx.fpLibraryName ?? "tscircuit";
+    if (!schContent) {
+      throw new Error(
+        "Schematic content not available. Run GenerateKicadSchAndPcbStage first."
+      );
+    }
+    const uniqueSymbols = /* @__PURE__ */ new Map();
+    try {
+      const parsed = parseKicadSexpr(schContent);
+      const sch = parsed.find(
+        (node) => node instanceof KicadSch2
+      );
+      if (!sch) {
+        this.ctx.symbolEntries = [];
+        this.finished = true;
+        return;
+      }
+      const libSymbols = sch.libSymbols;
+      if (!libSymbols) {
+        this.ctx.symbolEntries = [];
+        this.finished = true;
+        return;
+      }
+      const symbols3 = libSymbols.symbols ?? [];
+      for (const symbol of symbols3) {
+        const symbolName = this.sanitizeSymbolName(symbol.libraryId);
+        if (!uniqueSymbols.has(symbolName)) {
+          symbol.libraryId = symbolName;
+          this.updateFootprintProperty(symbol, fpLibraryName);
+          uniqueSymbols.set(symbolName, {
+            symbolName,
+            symbol
+          });
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to parse schematic for symbol extraction:", error);
+    }
+    this.ctx.symbolEntries = Array.from(uniqueSymbols.values());
+    this.finished = true;
+  }
+  /**
+   * Updates the Footprint property in a symbol to use the correct library name.
+   * Changes "tscircuit:footprint_name" to "fpLibraryName:footprint_name"
+   */
+  updateFootprintProperty(symbol, fpLibraryName) {
+    const properties = symbol.properties ?? [];
+    for (const prop of properties) {
+      if (prop.key === "Footprint" && prop.value) {
+        const parts = prop.value.split(":");
+        if (parts.length > 1) {
+          prop.value = `${fpLibraryName}:${parts[1]}`;
+        } else if (prop.value.trim()) {
+          prop.value = `${fpLibraryName}:${prop.value}`;
+        }
+      }
+    }
+  }
+  sanitizeSymbolName(libraryId) {
+    if (!libraryId) return "symbol";
+    const parts = libraryId.split(":");
+    const name = parts.length > 1 ? parts[1] : parts[0];
+    return name?.replace(/[\\\/]/g, "-").trim() || "symbol";
+  }
+  getOutput() {
+    return this.ctx.libraryOutput;
+  }
+};
+
+// lib/kicad-library/stages/ExtractFootprintsStage.ts
+import {
+  parseKicadSexpr as parseKicadSexpr2,
+  KicadPcb as KicadPcb2,
+  FootprintModel as FootprintModel2,
+  At as At2
+} from "kicadts";
+function getBasename(filePath) {
+  const parts = filePath.split(/[/\\]/);
+  return parts[parts.length - 1] || filePath;
+}
+var ExtractFootprintsStage = class extends ConverterStage {
+  _step() {
+    const kicadPcbString = this.ctx.kicadPcbString;
+    const fpLibraryName = this.ctx.fpLibraryName ?? "tscircuit";
+    if (!kicadPcbString) {
+      throw new Error(
+        "PCB content not available. Run GenerateKicadSchAndPcbStage first."
+      );
+    }
+    const uniqueFootprints = /* @__PURE__ */ new Map();
+    try {
+      const parsed = parseKicadSexpr2(kicadPcbString);
+      const pcb = parsed.find(
+        (node) => node instanceof KicadPcb2
+      );
+      if (!pcb) {
+        this.ctx.footprintEntries = [];
+        this.finished = true;
+        return;
+      }
+      const footprints = pcb.footprints ?? [];
+      for (const footprint of footprints) {
+        const sanitized = this.sanitizeFootprint(footprint, fpLibraryName);
+        if (!uniqueFootprints.has(sanitized.footprintName)) {
+          uniqueFootprints.set(sanitized.footprintName, sanitized);
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to parse PCB for footprint extraction:", error);
+    }
+    this.ctx.footprintEntries = Array.from(uniqueFootprints.values());
+    this.finished = true;
+  }
+  sanitizeFootprint(footprint, fpLibraryName) {
+    const libraryLink = footprint.libraryLink ?? "footprint";
+    const parts = libraryLink.split(":");
+    const footprintName = (parts.length > 1 ? parts[1] : parts[0])?.replace(/[\\\/]/g, "-").trim() || "footprint";
+    footprint.libraryLink = footprintName;
+    footprint.position = At2.from([0, 0, 0]);
+    footprint.locked = false;
+    footprint.placed = false;
+    footprint.uuid = void 0;
+    footprint.path = void 0;
+    footprint.sheetfile = void 0;
+    footprint.sheetname = void 0;
+    footprint.properties = [];
+    const texts = footprint.fpTexts ?? [];
+    for (const text of texts) {
+      text.uuid = void 0;
+      if (text.type === "reference") {
+        text.text = "REF**";
+      } else if (text.type === "value" && text.text.trim().length === 0) {
+        text.text = footprintName;
+      }
+    }
+    footprint.fpTexts = texts;
+    const pads = footprint.fpPads ?? [];
+    for (const pad of pads) {
+      pad.uuid = void 0;
+      pad.net = void 0;
+    }
+    footprint.fpPads = pads;
+    const models = footprint.models ?? [];
+    const updatedModels = [];
+    const modelFiles = [];
+    for (const model of models) {
+      if (model.path) {
+        const modelFilename = getBasename(model.path);
+        const newPath = `\${KIPRJMOD}/${fpLibraryName}.3dshapes/${modelFilename}`;
+        const newModel = new FootprintModel2(newPath);
+        if (model.offset) newModel.offset = model.offset;
+        if (model.scale) newModel.scale = model.scale;
+        if (model.rotate) newModel.rotate = model.rotate;
+        updatedModels.push(newModel);
+        modelFiles.push(model.path);
+      }
+    }
+    footprint.models = updatedModels;
+    return {
+      footprintName,
+      kicadModString: footprint.getString(),
+      model3dSourcePaths: modelFiles
+    };
+  }
+  getOutput() {
+    return this.ctx.libraryOutput;
+  }
+};
+
+// lib/kicad-library/stages/GenerateSymbolLibraryStage.ts
+import { KicadSymbolLib } from "kicadts";
+var KICAD_SYM_LIB_VERSION = 20211014;
+var GENERATOR = "circuit-json-to-kicad";
+var GenerateSymbolLibraryStage = class extends ConverterStage {
+  _step() {
+    const symbolEntries = this.ctx.symbolEntries ?? [];
+    const symbolLibrary = this.generateSymbolLibrary(symbolEntries);
+    if (!this.ctx.libraryOutput) {
+      this.ctx.libraryOutput = {
+        kicadSymString: "",
+        footprints: [],
+        fpLibTableString: "",
+        symLibTableString: "",
+        model3dSourcePaths: []
+      };
+    }
+    this.ctx.libraryOutput.kicadSymString = symbolLibrary;
+    this.finished = true;
+  }
+  generateSymbolLibrary(symbolEntries) {
+    const symbolLib = new KicadSymbolLib({
+      version: KICAD_SYM_LIB_VERSION,
+      generator: GENERATOR,
+      symbols: symbolEntries.map((entry) => entry.symbol)
+    });
+    return symbolLib.getString();
+  }
+  getOutput() {
+    return this.ctx.libraryOutput;
+  }
+};
+
+// lib/kicad-library/stages/GenerateLibraryTablesStage.ts
+var GenerateLibraryTablesStage = class extends ConverterStage {
+  _step() {
+    const libraryName = this.ctx.libraryName ?? "tscircuit";
+    const fpLibraryName = this.ctx.fpLibraryName ?? "tscircuit";
+    const footprintEntries = this.ctx.footprintEntries ?? [];
+    const model3dSourcePathsSet = /* @__PURE__ */ new Set();
+    for (const fp of footprintEntries) {
+      for (const modelPath of fp.model3dSourcePaths) {
+        model3dSourcePathsSet.add(modelPath);
+      }
+    }
+    const fpLibTableString = this.generateFpLibTable(fpLibraryName);
+    const symLibTableString = this.generateSymLibTable(libraryName);
+    if (!this.ctx.libraryOutput) {
+      this.ctx.libraryOutput = {
+        kicadSymString: "",
+        footprints: [],
+        fpLibTableString: "",
+        symLibTableString: "",
+        model3dSourcePaths: []
+      };
+    }
+    this.ctx.libraryOutput.footprints = footprintEntries;
+    this.ctx.libraryOutput.fpLibTableString = fpLibTableString;
+    this.ctx.libraryOutput.symLibTableString = symLibTableString;
+    this.ctx.libraryOutput.model3dSourcePaths = Array.from(
+      model3dSourcePathsSet
+    );
+    this.finished = true;
+  }
+  generateFpLibTable(fpLibraryName) {
+    return `(fp_lib_table
+  (version 7)
+  (lib (name "${fpLibraryName}") (type "KiCad") (uri "\${KIPRJMOD}/${fpLibraryName}.pretty") (options "") (descr "Generated by circuit-json-to-kicad"))
+)
+`;
+  }
+  generateSymLibTable(libraryName) {
+    return `(sym_lib_table
+  (version 7)
+  (lib (name "${libraryName}") (type "KiCad") (uri "\${KIPRJMOD}/${libraryName}.kicad_sym") (options "") (descr "Generated by circuit-json-to-kicad"))
+)
+`;
+  }
+  getOutput() {
+    return this.ctx.libraryOutput;
+  }
+};
+
+// lib/kicad-library/CircuitJsonToKicadLibraryConverter.ts
+var CircuitJsonToKicadLibraryConverter = class {
+  ctx;
+  pipeline;
+  currentStageIndex = 0;
+  finished = false;
+  get currentStage() {
+    return this.pipeline[this.currentStageIndex];
+  }
+  constructor(circuitJson, options = {}) {
+    this.ctx = {
+      db: cju4(circuitJson),
+      circuitJson,
+      libraryName: options.libraryName ?? "tscircuit",
+      fpLibraryName: options.footprintLibraryName ?? "tscircuit"
+    };
+    this.pipeline = [
+      new GenerateKicadSchAndPcbStage(circuitJson, this.ctx),
+      new ExtractSymbolsStage(circuitJson, this.ctx),
+      new ExtractFootprintsStage(circuitJson, this.ctx),
+      new GenerateSymbolLibraryStage(circuitJson, this.ctx),
+      new GenerateLibraryTablesStage(circuitJson, this.ctx)
+    ];
+  }
+  step() {
+    if (!this.currentStage) {
+      this.finished = true;
+      return;
+    }
+    this.currentStage.step();
+    if (this.currentStage.finished) {
+      this.currentStageIndex++;
+    }
+  }
+  runUntilFinished() {
+    while (!this.finished) {
+      this.step();
+    }
+  }
+  getOutput() {
+    if (!this.ctx.libraryOutput) {
+      throw new Error("Converter has not been run yet");
+    }
+    return this.ctx.libraryOutput;
+  }
+  getSymbolLibraryString() {
+    return this.getOutput().kicadSymString;
+  }
+  getFootprints() {
+    return this.getOutput().footprints;
+  }
+  getFpLibTableString() {
+    return this.getOutput().fpLibTableString;
+  }
+  getSymLibTableString() {
+    return this.getOutput().symLibTableString;
+  }
+  getModel3dSourcePaths() {
+    return this.getOutput().model3dSourcePaths;
+  }
+};
 export {
+  CircuitJsonToKicadLibraryConverter,
   CircuitJsonToKicadPcbConverter,
   CircuitJsonToKicadProConverter,
   CircuitJsonToKicadSchConverter

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "circuit-json-to-kicad",
   "main": "dist/index.js",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "type": "module",
   "files": [
     "dist"
@@ -21,7 +21,7 @@
     "@types/bun": "latest",
     "circuit-json": "^0.0.302",
     "circuit-to-svg": "^0.0.208",
-    "kicadts": "^0.0.22",
+    "kicadts": "^0.0.23",
     "schematic-symbols": "^0.0.202",
     "sharp": "^0.34.4",
     "transformation-matrix": "^3.1.0",