circuit-json-to-kicad 0.0.32 → 0.0.34

package/dist/index.d.ts

@@ -20,14 +20,25 @@ interface PcbNetInfo {
 interface SymbolEntry {
     symbolName: string;
     symbol: SchematicSymbol;
+    /**
+     * Whether this symbol is from a standard library footprint (has footprinter_string).
+     * If true, this is a builtin/standard symbol. If false, it's a custom/inline symbol.
+     */
+    isBuiltin?: boolean;
 }
 interface FootprintEntry {
     footprintName: string;
     kicadModString: string;
     model3dSourcePaths: string[];
+    /**
+     * Whether this footprint is from a standard library footprint (has footprinter_string).
+     * If true, this is a builtin/standard footprint. If false, it's a custom/inline footprint.
+     */
+    isBuiltin?: boolean;
 }
 interface KicadLibraryOutput {
     kicadSymString: string;
+    symbols: SymbolEntry[];
     footprints: FootprintEntry[];
     fpLibTableString: string;
     symLibTableString: string;
@@ -201,4 +212,72 @@ declare class CircuitJsonToKicadLibraryConverter {
     getModel3dSourcePaths(): string[];
 }
 
-export { CircuitJsonToKicadLibraryConverter, CircuitJsonToKicadPcbConverter, CircuitJsonToKicadProConverter, CircuitJsonToKicadSchConverter, type FootprintEntry, type KicadLibraryOutput, type SymbolEntry };
+interface KicadLibraryConverterOptions {
+    /**
+     * Name for the generated KiCad library (e.g., "my-library").
+     * This will be used for the user library files.
+     */
+    kicadLibraryName?: string;
+    /**
+     * The main entry point file for the library (e.g., "lib/my-library.ts").
+     * This file's exports define the public API of the library.
+     */
+    entrypoint: string;
+    /**
+     * Callback to build circuit JSON from a file path and export name.
+     * Should handle both board components and symbol components:
+     * - For board components: render inside a <board> element
+     * - For symbol components: render inside a <chip> with the symbol prop
+     *   (Note: tscircuit symbols cannot render standalone - they must be
+     *   used as a prop on a <chip> component)
+     * Return null if the export cannot be rendered.
+     */
+    buildFileToCircuitJson: (filePath: string, componentName: string) => Promise<CircuitJson | null>;
+    /**
+     * Callback to get all exports from a TSX/TS file.
+     * Must evaluate the file (not just parse) to handle `export * from` patterns.
+     */
+    getExportsFromTsxFile: (filePath: string) => Promise<string[]>;
+    /**
+     * Callback to resolve an export name to its file path.
+     * Returns the file path where the component is defined, or null if not resolvable.
+     */
+    resolveExportPath?: (entrypoint: string, exportName: string) => Promise<string | null>;
+    /**
+     * Whether to include builtin footprints/symbols (like 0402, soic8).
+     * Default: true
+     */
+    includeBuiltins?: boolean;
+}
+interface KicadLibraryConverterOutput {
+    /**
+     * Map of file paths to file contents for the generated KiCad library.
+     */
+    kicadProjectFsMap: Record<string, string | Buffer>;
+    /**
+     * Source paths to 3D model files that need to be copied.
+     */
+    model3dSourcePaths: string[];
+}
+
+/**
+ * Converts tscircuit component files to a KiCad library.
+ */
+declare class KicadLibraryConverter {
+    private options;
+    private output;
+    private ctx;
+    constructor(options: KicadLibraryConverterOptions);
+    run(): Promise<void>;
+    /**
+     * Builds tscircuit components to circuit-json.
+     */
+    private buildTscircuitComponents;
+    /**
+     * Extracts KiCad footprints and symbols from built tscircuit components.
+     */
+    private extractKicadComponents;
+    getOutput(): KicadLibraryConverterOutput;
+}
+
+export { CircuitJsonToKicadLibraryConverter, CircuitJsonToKicadPcbConverter, CircuitJsonToKicadProConverter, CircuitJsonToKicadSchConverter, type FootprintEntry, KicadLibraryConverter, type KicadLibraryConverterOptions, type KicadLibraryConverterOutput, type KicadLibraryOutput, type SymbolEntry };

package/dist/index.js

@@ -73,7 +73,7 @@ import {
   TextEffectsFont,
   Xy
 } from "kicadts";
-import { symbols } from "schematic-symbols";
+import { symbols as symbols2 } from "schematic-symbols";
 
 // lib/utils/getKicadCompatibleComponentName.ts
 function getKicadCompatibleComponentName(sourceComponent, cadComponent) {
@@ -103,14 +103,24 @@ function extractReferencePrefix(name) {
 }
 
 // lib/schematic/getLibraryId.ts
+import { symbols } from "schematic-symbols";
+function isBuiltinSymbol(symbolName) {
+  return symbolName in symbols;
+}
 function getLibraryId(sourceComp, schematicComp, cadComponent) {
   if (sourceComp.type !== "source_component") {
     if (schematicComp.symbol_name) {
+      if (isBuiltinSymbol(schematicComp.symbol_name)) {
+        return `Device:${schematicComp.symbol_name}`;
+      }
       return `Custom:${schematicComp.symbol_name}`;
     }
     return "Device:Component";
   }
   if (schematicComp.symbol_name) {
+    if (isBuiltinSymbol(schematicComp.symbol_name)) {
+      return `Device:${schematicComp.symbol_name}`;
+    }
     return `Custom:${schematicComp.symbol_name}`;
   }
   const ergonomicName = getKicadCompatibleComponentName(
@@ -200,7 +210,7 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
   }) {
     const symbolName = netLabel.symbol_name;
     if (!symbolName) return null;
-    const symbolData = symbols[symbolName];
+    const symbolData = symbols2[symbolName];
     if (!symbolData) return null;
     const libId = `Custom:${symbolName}`;
     return this.createLibrarySymbol({
@@ -220,7 +230,7 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
     if (symbolName.startsWith("generic_chip_")) {
       return this.createGenericChipSymbolData(schematicComponent, this.ctx.db);
     }
-    return symbols[symbolName] || null;
+    return symbols2[symbolName] || null;
   }
   /**
    * Create generic chip symbol data for chips without a symbol_name
@@ -620,7 +630,7 @@ import {
   TextEffectsJustify
 } from "kicadts";
 import { applyToPoint as applyToPoint2 } from "transformation-matrix";
-import { symbols as symbols2 } from "schematic-symbols";
+import { symbols as symbols3 } from "schematic-symbols";
 var AddSchematicSymbolsStage = class extends ConverterStage {
   _step() {
     const { kicadSch, db } = this.ctx;
@@ -629,7 +639,7 @@ var AddSchematicSymbolsStage = class extends ConverterStage {
       this.finished = true;
       return;
     }
-    const symbols3 = [];
+    const symbols4 = [];
     for (const schematicComponent of schematicComponents) {
       const sourceComponent = schematicComponent.source_component_id ? db.source_component.get(schematicComponent.source_component_id) : null;
       if (!sourceComponent) continue;
@@ -724,10 +734,10 @@ var AddSchematicSymbolsStage = class extends ConverterStage {
       project.paths.push(path);
       instances.projects.push(project);
       symbol._sxInstances = instances;
-      symbols3.push(symbol);
+      symbols4.push(symbol);
     }
     if (kicadSch) {
-      kicadSch.symbols = symbols3;
+      kicadSch.symbols = symbols4;
     }
     this.finished = true;
   }
@@ -748,7 +758,7 @@ var AddSchematicSymbolsStage = class extends ConverterStage {
       return { refTextPos: refTextPos2, valTextPos: valTextPos2 };
     }
     const symbolName = schematicComponent.symbol_name;
-    const symbol = symbols2[symbolName];
+    const symbol = symbols3[symbolName];
     if (!symbol) {
       return {
         refTextPos: { x: symbolKicadPos.x, y: symbolKicadPos.y - 6 },
@@ -874,7 +884,7 @@ var AddSchematicNetLabelsStage = class extends ConverterStage {
       this.finished = true;
       return;
     }
-    const symbols3 = [];
+    const symbols4 = [];
     const globalLabels = [];
     for (const netLabel of netLabels) {
       const labelText = netLabel.text || "";
@@ -886,7 +896,7 @@ var AddSchematicNetLabelsStage = class extends ConverterStage {
           symbolName
         );
         if (symbol) {
-          symbols3.push(symbol);
+          symbols4.push(symbol);
         }
       } else {
         const label = this.createGlobalLabel(netLabel, labelText);
@@ -895,9 +905,9 @@ var AddSchematicNetLabelsStage = class extends ConverterStage {
         }
       }
     }
-    if (kicadSch && symbols3.length > 0) {
+    if (kicadSch && symbols4.length > 0) {
       const existingSymbols = kicadSch.symbols || [];
-      kicadSch.symbols = [...existingSymbols, ...symbols3];
+      kicadSch.symbols = [...existingSymbols, ...symbols4];
     }
     if (kicadSch && globalLabels.length > 0) {
       kicadSch.globalLabels = [
@@ -2490,6 +2500,13 @@ var GenerateKicadSchAndPcbStage = class extends ConverterStage {
 // lib/kicad-library/stages/ExtractSymbolsStage.ts
 import { parseKicadSexpr, KicadSch as KicadSch2 } from "kicadts";
 var ExtractSymbolsStage = class extends ConverterStage {
+  /**
+   * Checks if a symbol is custom (user-specified symbol={<symbol>...</symbol>}).
+   * Custom symbols have libraryId starting with "Custom:".
+   */
+  isCustomSymbol(libraryId) {
+    return libraryId?.startsWith("Custom:") ?? false;
+  }
   _step() {
     const schContent = this.ctx.kicadSchString;
     const fpLibraryName = this.ctx.fpLibraryName ?? "tscircuit";
@@ -2515,15 +2532,17 @@ var ExtractSymbolsStage = class extends ConverterStage {
         this.finished = true;
         return;
       }
-      const symbols3 = libSymbols.symbols ?? [];
-      for (const symbol of symbols3) {
+      const symbols4 = libSymbols.symbols ?? [];
+      for (const symbol of symbols4) {
+        const isCustom = this.isCustomSymbol(symbol.libraryId);
         const symbolName = this.sanitizeSymbolName(symbol.libraryId);
         if (!uniqueSymbols.has(symbolName)) {
           symbol.libraryId = symbolName;
           this.updateFootprintProperty(symbol, fpLibraryName);
           uniqueSymbols.set(symbolName, {
             symbolName,
-            symbol
+            symbol,
+            isBuiltin: !isCustom
           });
         }
       }
@@ -2573,6 +2592,28 @@ function getBasename(filePath) {
   return parts[parts.length - 1] || filePath;
 }
 var ExtractFootprintsStage = class extends ConverterStage {
+  /**
+   * Builds a set of custom footprint names.
+   * These are components WITHOUT footprinter_string.
+   */
+  findCustomFootprintNames() {
+    const customNames = /* @__PURE__ */ new Set();
+    const cadComponents = this.ctx.db.cad_component?.list() ?? [];
+    const sourceComponents = this.ctx.db.source_component;
+    for (const cadComponent of cadComponents) {
+      if (!cadComponent.footprinter_string) {
+        const sourceComp = cadComponent.source_component_id ? sourceComponents?.get(cadComponent.source_component_id) : null;
+        if (sourceComp) {
+          const footprintName = getKicadCompatibleComponentName(
+            sourceComp,
+            cadComponent
+          );
+          customNames.add(footprintName);
+        }
+      }
+    }
+    return customNames;
+  }
   _step() {
     const kicadPcbString = this.ctx.kicadPcbString;
     const fpLibraryName = this.ctx.fpLibraryName ?? "tscircuit";
@@ -2581,6 +2622,7 @@ var ExtractFootprintsStage = class extends ConverterStage {
         "PCB content not available. Run GenerateKicadSchAndPcbStage first."
       );
     }
+    const customFootprintNames = this.findCustomFootprintNames();
     const uniqueFootprints = /* @__PURE__ */ new Map();
     try {
       const parsed = parseKicadSexpr2(kicadPcbString);
@@ -2594,9 +2636,13 @@ var ExtractFootprintsStage = class extends ConverterStage {
       }
       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);
+        const footprintEntry = this.sanitizeFootprint({
+          footprint,
+          fpLibraryName,
+          customFootprintNames
+        });
+        if (!uniqueFootprints.has(footprintEntry.footprintName)) {
+          uniqueFootprints.set(footprintEntry.footprintName, footprintEntry);
         }
       }
     } catch (error) {
@@ -2605,10 +2651,15 @@ var ExtractFootprintsStage = class extends ConverterStage {
     this.ctx.footprintEntries = Array.from(uniqueFootprints.values());
     this.finished = true;
   }
-  sanitizeFootprint(footprint, fpLibraryName) {
+  sanitizeFootprint({
+    footprint,
+    fpLibraryName,
+    customFootprintNames
+  }) {
     const libraryLink = footprint.libraryLink ?? "footprint";
     const parts = libraryLink.split(":");
     const footprintName = (parts.length > 1 ? parts[1] : parts[0])?.replace(/[\\\/]/g, "-").trim() || "footprint";
+    const isBuiltin = !customFootprintNames.has(footprintName);
     footprint.libraryLink = footprintName;
     footprint.position = At2.from([0, 0, 0]);
     footprint.locked = false;
@@ -2653,7 +2704,8 @@ var ExtractFootprintsStage = class extends ConverterStage {
     return {
       footprintName,
       kicadModString: footprint.getString(),
-      model3dSourcePaths: modelFiles
+      model3dSourcePaths: modelFiles,
+      isBuiltin
     };
   }
   getOutput() {
@@ -2672,6 +2724,7 @@ var GenerateSymbolLibraryStage = class extends ConverterStage {
     if (!this.ctx.libraryOutput) {
       this.ctx.libraryOutput = {
         kicadSymString: "",
+        symbols: [],
         footprints: [],
         fpLibTableString: "",
         symLibTableString: "",
@@ -2700,6 +2753,7 @@ var GenerateLibraryTablesStage = class extends ConverterStage {
     const libraryName = this.ctx.libraryName ?? "tscircuit";
     const fpLibraryName = this.ctx.fpLibraryName ?? "tscircuit";
     const footprintEntries = this.ctx.footprintEntries ?? [];
+    const symbolEntries = this.ctx.symbolEntries ?? [];
     const model3dSourcePathsSet = /* @__PURE__ */ new Set();
     for (const fp of footprintEntries) {
       for (const modelPath of fp.model3dSourcePaths) {
@@ -2711,12 +2765,14 @@ var GenerateLibraryTablesStage = class extends ConverterStage {
     if (!this.ctx.libraryOutput) {
       this.ctx.libraryOutput = {
         kicadSymString: "",
+        symbols: [],
         footprints: [],
         fpLibTableString: "",
         symLibTableString: "",
         model3dSourcePaths: []
       };
     }
+    this.ctx.libraryOutput.symbols = symbolEntries;
     this.ctx.libraryOutput.footprints = footprintEntries;
     this.ctx.libraryOutput.fpLibTableString = fpLibTableString;
     this.ctx.libraryOutput.symLibTableString = symLibTableString;
@@ -2805,9 +2861,425 @@ var CircuitJsonToKicadLibraryConverter = class {
     return this.getOutput().model3dSourcePaths;
   }
 };
+
+// lib/kicad-library/kicad-library-converter-utils/renameKicadFootprint.ts
+import { parseKicadMod } from "kicadts";
+function renameKicadFootprint(params) {
+  const { kicadFootprint, newKicadFootprintName, kicadLibraryName } = params;
+  const footprint = parseKicadMod(kicadFootprint.kicadModString);
+  footprint.libraryLink = newKicadFootprintName;
+  for (const model of footprint.models) {
+    const currentPath = model.path;
+    if (currentPath.includes("${KIPRJMOD}/")) {
+      const filename = currentPath.split("/").pop() ?? "";
+      model.path = `\${KIPRJMOD}/3dmodels/${kicadLibraryName}.3dshapes/${filename}`;
+    }
+  }
+  return {
+    footprintName: newKicadFootprintName,
+    kicadModString: footprint.getString(),
+    model3dSourcePaths: kicadFootprint.model3dSourcePaths
+  };
+}
+
+// lib/kicad-library/stages/ClassifyKicadFootprintsStage.ts
+function classifyKicadFootprints(ctx) {
+  for (const extractedKicadComponent of ctx.extractedKicadComponents) {
+    classifyFootprintsForComponent({
+      ctx,
+      extractedKicadComponent
+    });
+  }
+}
+function classifyFootprintsForComponent({
+  ctx,
+  extractedKicadComponent
+}) {
+  const { tscircuitComponentName, kicadFootprints } = extractedKicadComponent;
+  let hasAddedUserFootprint = false;
+  for (const kicadFootprint of kicadFootprints) {
+    if (kicadFootprint.isBuiltin) {
+      addBuiltinFootprint({ ctx, kicadFootprint });
+    } else {
+      if (!hasAddedUserFootprint) {
+        hasAddedUserFootprint = true;
+        const renamedFootprint = renameKicadFootprint({
+          kicadFootprint,
+          newKicadFootprintName: tscircuitComponentName,
+          kicadLibraryName: ctx.kicadLibraryName
+        });
+        addUserFootprint({ ctx, kicadFootprint: renamedFootprint });
+      } else {
+        addUserFootprint({ ctx, kicadFootprint });
+      }
+    }
+  }
+}
+function addUserFootprint({
+  ctx,
+  kicadFootprint
+}) {
+  const alreadyExists = ctx.userKicadFootprints.some(
+    (fp) => fp.footprintName === kicadFootprint.footprintName
+  );
+  if (!alreadyExists) {
+    ctx.userKicadFootprints.push(kicadFootprint);
+  }
+}
+function addBuiltinFootprint({
+  ctx,
+  kicadFootprint
+}) {
+  const alreadyExists = ctx.builtinKicadFootprints.some(
+    (fp) => fp.footprintName === kicadFootprint.footprintName
+  );
+  if (!alreadyExists) {
+    ctx.builtinKicadFootprints.push(kicadFootprint);
+  }
+}
+function componentHasCustomFootprint(extractedKicadComponent) {
+  return extractedKicadComponent.kicadFootprints.some((fp) => !fp.isBuiltin);
+}
+
+// lib/kicad-library/kicad-library-converter-utils/renameKicadSymbol.ts
+function renameKicadSymbol(params) {
+  const { kicadSymbol, newKicadSymbolName } = params;
+  const symbol = kicadSymbol.symbol;
+  const oldName = symbol.libraryId;
+  symbol.libraryId = newKicadSymbolName;
+  if (oldName && symbol.subSymbols) {
+    for (const subSymbol of symbol.subSymbols) {
+      if (subSymbol.libraryId?.startsWith(oldName)) {
+        const suffix = subSymbol.libraryId.slice(oldName.length);
+        subSymbol.libraryId = newKicadSymbolName + suffix;
+      }
+    }
+  }
+  return { symbolName: newKicadSymbolName, symbol };
+}
+
+// lib/kicad-library/kicad-library-converter-utils/updateKicadSymbolFootprint.ts
+function updateKicadSymbolFootprint(params) {
+  const { kicadSymbol, kicadLibraryName, kicadFootprintName } = params;
+  const properties = kicadSymbol.symbol.properties ?? [];
+  for (const prop of properties) {
+    if (prop.key === "Footprint") {
+      prop.value = `${kicadLibraryName}:${kicadFootprintName}`;
+    }
+  }
+}
+
+// lib/kicad-library/kicad-library-converter-utils/updateBuiltinKicadSymbolFootprint.ts
+function updateBuiltinKicadSymbolFootprint(kicadSymbol) {
+  const symbol = kicadSymbol.symbol;
+  const properties = symbol.properties ?? [];
+  for (const prop of properties) {
+    if (prop.key === "Footprint" && prop.value) {
+      const parts = prop.value.split(":");
+      const footprintName = parts.length > 1 ? parts[1] : parts[0];
+      prop.value = `tscircuit_builtin:${footprintName}`;
+    }
+  }
+  return { symbolName: kicadSymbol.symbolName, symbol };
+}
+
+// lib/kicad-library/stages/ClassifyKicadSymbolsStage.ts
+function classifyKicadSymbols(ctx) {
+  for (const extractedKicadComponent of ctx.extractedKicadComponents) {
+    classifySymbolsForComponent({
+      ctx,
+      extractedKicadComponent
+    });
+  }
+}
+function classifySymbolsForComponent({
+  ctx,
+  extractedKicadComponent
+}) {
+  const { tscircuitComponentName, kicadSymbols } = extractedKicadComponent;
+  const hasCustomFootprint = componentHasCustomFootprint(
+    extractedKicadComponent
+  );
+  let hasAddedUserSymbol = false;
+  for (const kicadSymbol of kicadSymbols) {
+    if (!kicadSymbol.isBuiltin) {
+      if (!hasAddedUserSymbol) {
+        hasAddedUserSymbol = true;
+        const renamedSymbol = renameKicadSymbol({
+          kicadSymbol,
+          newKicadSymbolName: tscircuitComponentName
+        });
+        if (hasCustomFootprint) {
+          updateKicadSymbolFootprint({
+            kicadSymbol: renamedSymbol,
+            kicadLibraryName: ctx.kicadLibraryName,
+            kicadFootprintName: tscircuitComponentName
+          });
+        }
+        addUserSymbol({ ctx, kicadSymbol: renamedSymbol });
+      } else {
+        addUserSymbol({ ctx, kicadSymbol });
+      }
+    } else if (hasCustomFootprint && !hasAddedUserSymbol) {
+      hasAddedUserSymbol = true;
+      const renamedSymbol = renameKicadSymbol({
+        kicadSymbol,
+        newKicadSymbolName: tscircuitComponentName
+      });
+      updateKicadSymbolFootprint({
+        kicadSymbol: renamedSymbol,
+        kicadLibraryName: ctx.kicadLibraryName,
+        kicadFootprintName: tscircuitComponentName
+      });
+      addUserSymbol({ ctx, kicadSymbol: renamedSymbol });
+    } else {
+      const updatedSymbol = updateBuiltinKicadSymbolFootprint(kicadSymbol);
+      addBuiltinSymbol({ ctx, kicadSymbol: updatedSymbol });
+    }
+  }
+}
+function addUserSymbol({
+  ctx,
+  kicadSymbol
+}) {
+  const alreadyExists = ctx.userKicadSymbols.some(
+    (s) => s.symbolName === kicadSymbol.symbolName
+  );
+  if (!alreadyExists) {
+    ctx.userKicadSymbols.push(kicadSymbol);
+  }
+}
+function addBuiltinSymbol({
+  ctx,
+  kicadSymbol
+}) {
+  const alreadyExists = ctx.builtinKicadSymbols.some(
+    (s) => s.symbolName === kicadSymbol.symbolName
+  );
+  if (!alreadyExists) {
+    ctx.builtinKicadSymbols.push(kicadSymbol);
+  }
+}
+
+// lib/kicad-library/stages/BuildKicadLibraryFilesStage.ts
+import { KicadSymbolLib as KicadSymbolLib2 } from "kicadts";
+
+// lib/kicad-library/kicad-library-converter-utils/generateSymLibTable.ts
+function generateSymLibTable(params) {
+  const { kicadLibraryName, includeBuiltin } = params;
+  let content = "(sym_lib_table\n";
+  content += `  (lib (name "${kicadLibraryName}")(type "KiCad")(uri "\${KIPRJMOD}/symbols/${kicadLibraryName}.kicad_sym")(options "")(descr ""))
+`;
+  if (includeBuiltin) {
+    content += `  (lib (name "tscircuit_builtin")(type "KiCad")(uri "\${KIPRJMOD}/symbols/tscircuit_builtin.kicad_sym")(options "")(descr ""))
+`;
+  }
+  content += ")\n";
+  return content;
+}
+
+// lib/kicad-library/kicad-library-converter-utils/generateFpLibTable.ts
+function generateFpLibTable(params) {
+  const { kicadLibraryName, includeBuiltin } = params;
+  let content = "(fp_lib_table\n";
+  content += `  (lib (name "${kicadLibraryName}")(type "KiCad")(uri "\${KIPRJMOD}/footprints/${kicadLibraryName}.pretty")(options "")(descr ""))
+`;
+  if (includeBuiltin) {
+    content += `  (lib (name "tscircuit_builtin")(type "KiCad")(uri "\${KIPRJMOD}/footprints/tscircuit_builtin.pretty")(options "")(descr ""))
+`;
+  }
+  content += ")\n";
+  return content;
+}
+
+// lib/kicad-library/stages/BuildKicadLibraryFilesStage.ts
+var KICAD_SYM_LIB_VERSION2 = 20211014;
+var KICAD_GENERATOR = "circuit-json-to-kicad";
+function buildKicadLibraryFiles(ctx) {
+  buildUserSymbolLibrary(ctx);
+  buildBuiltinSymbolLibrary(ctx);
+  buildUserFootprintLibrary(ctx);
+  buildBuiltinFootprintLibrary(ctx);
+  buildLibraryTables(ctx);
+}
+function buildUserSymbolLibrary(ctx) {
+  if (ctx.userKicadSymbols.length === 0) return;
+  const symbolLib = new KicadSymbolLib2({
+    version: KICAD_SYM_LIB_VERSION2,
+    generator: KICAD_GENERATOR,
+    symbols: ctx.userKicadSymbols.map((s) => s.symbol)
+  });
+  ctx.kicadProjectFsMap[`symbols/${ctx.kicadLibraryName}.kicad_sym`] = symbolLib.getString();
+}
+function buildBuiltinSymbolLibrary(ctx) {
+  if (!ctx.includeBuiltins || ctx.builtinKicadSymbols.length === 0) return;
+  const symbolLib = new KicadSymbolLib2({
+    version: KICAD_SYM_LIB_VERSION2,
+    generator: KICAD_GENERATOR,
+    symbols: ctx.builtinKicadSymbols.map((s) => s.symbol)
+  });
+  ctx.kicadProjectFsMap["symbols/tscircuit_builtin.kicad_sym"] = symbolLib.getString();
+}
+function buildUserFootprintLibrary(ctx) {
+  for (const kicadFootprint of ctx.userKicadFootprints) {
+    const filePath = `footprints/${ctx.kicadLibraryName}.pretty/${kicadFootprint.footprintName}.kicad_mod`;
+    ctx.kicadProjectFsMap[filePath] = kicadFootprint.kicadModString;
+  }
+}
+function buildBuiltinFootprintLibrary(ctx) {
+  if (!ctx.includeBuiltins || ctx.builtinKicadFootprints.length === 0) return;
+  for (const kicadFootprint of ctx.builtinKicadFootprints) {
+    const filePath = `footprints/tscircuit_builtin.pretty/${kicadFootprint.footprintName}.kicad_mod`;
+    ctx.kicadProjectFsMap[filePath] = kicadFootprint.kicadModString;
+  }
+}
+function buildLibraryTables(ctx) {
+  const hasBuiltinFootprints = ctx.includeBuiltins && ctx.builtinKicadFootprints.length > 0;
+  const hasBuiltinSymbols = ctx.includeBuiltins && ctx.builtinKicadSymbols.length > 0;
+  ctx.kicadProjectFsMap["fp-lib-table"] = generateFpLibTable({
+    kicadLibraryName: ctx.kicadLibraryName,
+    includeBuiltin: hasBuiltinFootprints
+  });
+  ctx.kicadProjectFsMap["sym-lib-table"] = generateSymLibTable({
+    kicadLibraryName: ctx.kicadLibraryName,
+    includeBuiltin: hasBuiltinSymbols
+  });
+}
+
+// lib/kicad-library/KicadLibraryConverter.ts
+var KicadLibraryConverter = class {
+  options;
+  output = null;
+  ctx;
+  constructor(options) {
+    this.options = options;
+    this.ctx = createKicadLibraryConverterContext({
+      kicadLibraryName: options.kicadLibraryName ?? "tscircuit_library",
+      includeBuiltins: options.includeBuiltins ?? true
+    });
+  }
+  async run() {
+    this.ctx.builtTscircuitComponents = await this.buildTscircuitComponents();
+    this.ctx.extractedKicadComponents = this.extractKicadComponents();
+    classifyKicadFootprints(this.ctx);
+    classifyKicadSymbols(this.ctx);
+    buildKicadLibraryFiles(this.ctx);
+    this.output = {
+      kicadProjectFsMap: this.ctx.kicadProjectFsMap,
+      model3dSourcePaths: this.ctx.model3dSourcePaths
+    };
+  }
+  /**
+   * Builds tscircuit components to circuit-json.
+   */
+  async buildTscircuitComponents() {
+    const builtTscircuitComponents = [];
+    const { entrypoint } = this.options;
+    const exports = await this.options.getExportsFromTsxFile(entrypoint);
+    const namedExports = exports.filter(
+      (name) => name !== "default" && /^[A-Z]/.test(name)
+    );
+    for (const exportName of namedExports) {
+      let componentPath = entrypoint;
+      if (this.options.resolveExportPath) {
+        const resolved = await this.options.resolveExportPath(
+          entrypoint,
+          exportName
+        );
+        if (resolved) componentPath = resolved;
+      }
+      const circuitJson = await this.options.buildFileToCircuitJson(
+        componentPath,
+        exportName
+      );
+      if (circuitJson && (!Array.isArray(circuitJson) || circuitJson.length > 0)) {
+        builtTscircuitComponents.push({
+          tscircuitComponentName: exportName,
+          circuitJson
+        });
+      }
+    }
+    if (exports.includes("default")) {
+      let componentPath = entrypoint;
+      if (this.options.resolveExportPath) {
+        const resolved = await this.options.resolveExportPath(
+          entrypoint,
+          "default"
+        );
+        if (resolved) componentPath = resolved;
+      }
+      const componentName = deriveComponentNameFromPath(componentPath);
+      const circuitJson = await this.options.buildFileToCircuitJson(
+        componentPath,
+        "default"
+      );
+      if (circuitJson && (!Array.isArray(circuitJson) || circuitJson.length > 0)) {
+        builtTscircuitComponents.push({
+          tscircuitComponentName: componentName,
+          circuitJson
+        });
+      }
+    }
+    return builtTscircuitComponents;
+  }
+  /**
+   * Extracts KiCad footprints and symbols from built tscircuit components.
+   */
+  extractKicadComponents() {
+    const extractedKicadComponents = [];
+    for (const builtTscircuitComponent of this.ctx.builtTscircuitComponents) {
+      const { tscircuitComponentName, circuitJson } = builtTscircuitComponent;
+      const libConverter = new CircuitJsonToKicadLibraryConverter(circuitJson, {
+        libraryName: this.ctx.kicadLibraryName,
+        footprintLibraryName: this.ctx.kicadLibraryName
+      });
+      libConverter.runUntilFinished();
+      const libOutput = libConverter.getOutput();
+      for (const path of libOutput.model3dSourcePaths) {
+        if (!this.ctx.model3dSourcePaths.includes(path)) {
+          this.ctx.model3dSourcePaths.push(path);
+        }
+      }
+      extractedKicadComponents.push({
+        tscircuitComponentName,
+        kicadFootprints: libOutput.footprints,
+        kicadSymbols: libOutput.symbols,
+        model3dSourcePaths: libOutput.model3dSourcePaths
+      });
+    }
+    return extractedKicadComponents;
+  }
+  getOutput() {
+    if (!this.output) {
+      throw new Error(
+        "Converter has not been run yet. Call run() before getOutput()."
+      );
+    }
+    return this.output;
+  }
+};
+function createKicadLibraryConverterContext(params) {
+  return {
+    kicadLibraryName: params.kicadLibraryName,
+    includeBuiltins: params.includeBuiltins,
+    builtTscircuitComponents: [],
+    extractedKicadComponents: [],
+    userKicadFootprints: [],
+    builtinKicadFootprints: [],
+    userKicadSymbols: [],
+    builtinKicadSymbols: [],
+    model3dSourcePaths: [],
+    kicadProjectFsMap: {}
+  };
+}
+function deriveComponentNameFromPath(filePath) {
+  const filename = filePath.split(/[/\\]/).pop() || filePath;
+  return filename.replace(/\.(tsx?|jsx?)$/, "");
+}
 export {
   CircuitJsonToKicadLibraryConverter,
   CircuitJsonToKicadPcbConverter,
   CircuitJsonToKicadProConverter,
-  CircuitJsonToKicadSchConverter
+  CircuitJsonToKicadSchConverter,
+  KicadLibraryConverter
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "circuit-json-to-kicad",
   "main": "dist/index.js",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "type": "module",
   "files": [
     "dist"