circuit-json-to-kicad 0.0.29 → 0.0.31

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

@@ -75,33 +75,50 @@ import {
 } from "kicadts";
 import { symbols } from "schematic-symbols";
 
+// lib/utils/getKicadCompatibleComponentName.ts
+function getKicadCompatibleComponentName(sourceComponent, cadComponent) {
+  if (sourceComponent.manufacturer_part_number) {
+    return sanitizeName(sourceComponent.manufacturer_part_number);
+  }
+  const cleanType = getCleanTypeName(sourceComponent.ftype);
+  const footprinterString = cadComponent?.footprinter_string;
+  if (footprinterString) {
+    return sanitizeName(`${cleanType}_${footprinterString}`);
+  }
+  return sanitizeName(cleanType);
+}
+function getCleanTypeName(ftype) {
+  if (!ftype) return "component";
+  let cleanName = ftype.replace(/^simple_/, "");
+  if (!cleanName) return "component";
+  return cleanName;
+}
+function sanitizeName(name) {
+  return name.replace(/[\\\/:\s]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").trim() || "component";
+}
+function extractReferencePrefix(name) {
+  if (!name) return "U";
+  const match = name.match(/^([A-Za-z]+)/);
+  return match?.[1]?.toUpperCase() ?? "U";
+}
+
 // lib/schematic/getLibraryId.ts
-function getLibraryId(sourceComp, schematicComp) {
+function getLibraryId(sourceComp, schematicComp, cadComponent) {
   if (sourceComp.type !== "source_component") {
     if (schematicComp.symbol_name) {
       return `Custom:${schematicComp.symbol_name}`;
     }
     return "Device:Component";
   }
-  if (sourceComp.ftype === "simple_resistor") {
-    return `Device:R_${sourceComp.source_component_id}`;
-  }
-  if (sourceComp.ftype === "simple_capacitor") {
-    return `Device:C_${sourceComp.source_component_id}`;
-  }
-  if (sourceComp.ftype === "simple_inductor") {
-    return `Device:L_${sourceComp.source_component_id}`;
-  }
-  if (sourceComp.ftype === "simple_diode") {
-    return `Device:D_${sourceComp.source_component_id}`;
-  }
-  if (sourceComp.ftype === "simple_chip") {
-    return `Device:U_${sourceComp.source_component_id}`;
-  }
   if (schematicComp.symbol_name) {
     return `Custom:${schematicComp.symbol_name}`;
   }
-  return `Device:Component_${sourceComp.source_component_id}`;
+  const ergonomicName = getKicadCompatibleComponentName(
+    sourceComp,
+    cadComponent
+  );
+  const refPrefix = extractReferencePrefix(sourceComp.name);
+  return `Device:${refPrefix}_${ergonomicName}`;
 }
 
 // lib/schematic/stages/AddLibrarySymbolsStage.ts
@@ -149,13 +166,19 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
     const { db } = this.ctx;
     const sourceComp = schematicComponent.source_component_id ? db.source_component.get(schematicComponent.source_component_id) : null;
     if (!sourceComp) return null;
+    const cadComponent = db.cad_component?.list()?.find(
+      (cad) => cad.source_component_id === sourceComp.source_component_id
+    );
     const symbolName = schematicComponent.symbol_name || (sourceComp.ftype === "simple_chip" ? `generic_chip_${schematicComponent.source_component_id}` : null);
     if (!symbolName) return null;
     const symbolData = this.getSymbolData(symbolName, schematicComponent);
     if (!symbolData) return null;
-    const libId = getLibraryId(sourceComp, schematicComponent);
+    const libId = getLibraryId(sourceComp, schematicComponent, cadComponent);
     const isChip = sourceComp.ftype === "simple_chip";
-    const footprintName = sourceComp.ftype || "";
+    const footprintName = getKicadCompatibleComponentName(
+      sourceComp,
+      cadComponent
+    );
     return this.createLibrarySymbol({
       libId,
       symbolData,
@@ -626,7 +649,14 @@ var AddSchematicSymbolsStage = class extends ConverterStage {
         uuid,
         fieldsAutoplaced: true
       });
-      const libId = getLibraryId(sourceComponent, schematicComponent);
+      const cadComponent = db.cad_component?.list()?.find(
+        (cad) => cad.source_component_id === sourceComponent.source_component_id
+      );
+      const libId = getLibraryId(
+        sourceComponent,
+        schematicComponent,
+        cadComponent
+      );
       const symLibId = new SymbolLibId(libId);
       symbol._sxLibId = symLibId;
       const { reference, value, description } = this.getComponentMetadata(sourceComponent);
@@ -1842,7 +1872,13 @@ var AddFootprintsStage = class extends ConverterStage {
     }
     const component = this.pcbComponents[this.componentsProcessed];
     const sourceComponent = component.source_component_id ? this.ctx.db.source_component.get(component.source_component_id) : null;
-    const footprintName = sourceComponent?.ftype || "Unknown";
+    const cadComponent = this.getCadComponentForPcbComponent(
+      component.pcb_component_id
+    );
+    const footprintName = sourceComponent ? getKicadCompatibleComponentName(
+      sourceComponent,
+      cadComponent
+    ) : "Unknown";
     const transformedPos = applyToPoint9(c2kMatPcb, {
       x: component.center.x,
       y: component.center.y
@@ -1919,9 +1955,6 @@ var AddFootprintsStage = class extends ConverterStage {
       }
     }
     footprint.fpPads = fpPads;
-    const cadComponent = this.getCadComponentForPcbComponent(
-      component.pcb_component_id
-    );
     if (cadComponent) {
       const models = this.create3DModelsFromCadComponent(
         cadComponent,
@@ -2430,7 +2463,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.29",
+  "version": "0.0.31",
   "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",