kicad-to-circuit-json 0.0.78 → 0.0.80

package/dist/index.d.ts

@@ -1,11 +1,92 @@
+import { AnyCircuitElement } from 'circuit-json';
 import { CircuitJsonUtilObjects } from '@tscircuit/circuit-json-util';
 import { KicadPcb, KicadSch } from 'kicadts';
 import { Matrix } from 'transformation-matrix';
 
+interface KicadSymbolLibPinAlternate {
+    name: string;
+    electricalType?: string;
+    graphicStyle?: string;
+}
+interface KicadSymbolLibPin {
+    name: string;
+    number: string;
+    electricalType?: string;
+    graphicStyle?: string;
+    at?: {
+        x: number;
+        y: number;
+        angle: number;
+    };
+    length?: number;
+    hidden?: boolean;
+    alternates?: KicadSymbolLibPinAlternate[];
+}
+interface KicadSymbolLibPoint {
+    x: number;
+    y: number;
+}
+interface KicadSymbolLibStroke {
+    width?: number;
+    type?: string;
+}
+interface KicadSymbolLibFill {
+    type?: string;
+}
+interface KicadSymbolLibPolyline {
+    points: KicadSymbolLibPoint[];
+    stroke?: KicadSymbolLibStroke;
+    fill?: KicadSymbolLibFill;
+}
+interface KicadSymbolLibRectangle {
+    start: KicadSymbolLibPoint;
+    end: KicadSymbolLibPoint;
+    stroke?: KicadSymbolLibStroke;
+    fill?: KicadSymbolLibFill;
+}
+interface KicadSymbolLibCircle {
+    center: KicadSymbolLibPoint;
+    radius: number;
+    stroke?: KicadSymbolLibStroke;
+    fill?: KicadSymbolLibFill;
+}
+interface KicadSymbolLibArc {
+    start: KicadSymbolLibPoint;
+    mid: KicadSymbolLibPoint;
+    end: KicadSymbolLibPoint;
+    stroke?: KicadSymbolLibStroke;
+}
+interface KicadSymbolLibText {
+    text: string;
+    at: {
+        x: number;
+        y: number;
+        angle: number;
+    };
+    fontSize?: number;
+}
+interface KicadSymbolLibSymbol {
+    name: string;
+    properties: Record<string, string>;
+    pins: KicadSymbolLibPin[];
+    polylines: KicadSymbolLibPolyline[];
+    rectangles: KicadSymbolLibRectangle[];
+    circles: KicadSymbolLibCircle[];
+    arcs: KicadSymbolLibArc[];
+    texts: KicadSymbolLibText[];
+    subSymbols: KicadSymbolLibSymbol[];
+}
+interface KicadSymbolLib {
+    version?: string;
+    generator?: string;
+    generatorVersion?: string;
+    symbols: KicadSymbolLibSymbol[];
+}
 interface ConverterContext {
     db: CircuitJsonUtilObjects;
     kicadPcb?: KicadPcb;
     kicadSch?: KicadSch;
+    kicadSymbolLib?: KicadSymbolLib;
     k2cMatSch?: Matrix;
     k2cMatPcb?: Matrix;
     netNumToName?: Map<number, string>;
@@ -56,7 +137,7 @@ declare class KicadToCircuitJsonConverter {
     initializePipeline(): void;
     step(): boolean;
     runUntilFinished(): void;
-    getOutput(): any[];
+    getOutput(): AnyCircuitElement[];
     getOutputString(): string;
     getWarnings(): string[];
     getStats(): {
@@ -265,4 +346,51 @@ declare class CollectSourceTracesStage extends ConverterStage {
     private createSourceNet;
 }
 
-export { CollectFootprintsStage, CollectGraphicsStage, CollectLibrarySymbolsStage, CollectNetsStage, CollectSchematicTracesStage, CollectSourceTracesStage, CollectTracesStage, CollectViasStage, CollectZonesStage, type ConverterContext, ConverterStage, InitializePcbContextStage, InitializeSchematicContextStage, KicadToCircuitJsonConverter };
+/**
+ * InitializeSymbolLibraryContextStage prepares shared state for .kicad_sym
+ * conversion. Symbol libraries have no schematic placements, so this branch
+ * emits source-level Circuit JSON only.
+ */
+declare class InitializeSymbolLibraryContextStage extends ConverterStage {
+    step(): boolean;
+}
+
+/**
+ * CollectSymbolLibrarySymbolsStage converts KiCad symbol-library definitions
+ * into source-level Circuit JSON:
+ * - source_component for each top-level library symbol
+ * - source_port for each physical pin in the symbol definition
+ * - schematic_component and schematic_port preview geometry for snapshots
+ */
+declare class CollectSymbolLibrarySymbolsStage extends ConverterStage {
+    private processedSymbols;
+    private previewIndex;
+    step(): boolean;
+    private processSymbol;
+    private getKicadSymbolExportFileName;
+    private collectPins;
+    private collectPolylines;
+    private collectRectangles;
+    private collectCircles;
+    private collectArcs;
+    private collectTexts;
+    private createSchematicPreview;
+    private getPreviewCenter;
+    private getPinBounds;
+    private getPreviewScale;
+    private createSchematicPrimitives;
+    private createPolylinePrimitives;
+    private toSchematicPoint;
+    private toStrokeWidth;
+    private isFilled;
+    private getArcGeometry;
+    private getAngleDegrees;
+    private getManufacturerPartNumber;
+    private createSourceComponentData;
+    private inferFtype;
+    private getPortName;
+    private getSourcePortPinMetadata;
+    private getSchematicPortPinMetadata;
+}
+
+export { CollectFootprintsStage, CollectGraphicsStage, CollectLibrarySymbolsStage, CollectNetsStage, CollectSchematicTracesStage, CollectSourceTracesStage, CollectSymbolLibrarySymbolsStage, CollectTracesStage, CollectViasStage, CollectZonesStage, type ConverterContext, ConverterStage, InitializePcbContextStage, InitializeSchematicContextStage, InitializeSymbolLibraryContextStage, KicadToCircuitJsonConverter };

package/dist/index.js

@@ -2,6 +2,255 @@
 import { cju } from "@tscircuit/circuit-json-util";
 import { parseKicadPcb, parseKicadSch } from "kicadts";
 
+// lib/parseKicadSymbolLib.ts
+function parseKicadSymbolLib(content) {
+  const expressions = parseSExpr(content);
+  const root = expressions.find(
+    (expr) => isList(expr) && expr[0] === "kicad_symbol_lib"
+  );
+  if (!root) {
+    throw new Error("Expected kicad_symbol_lib root in .kicad_sym file");
+  }
+  return {
+    version: getChildScalar(root, "version"),
+    generator: getChildScalar(root, "generator"),
+    generatorVersion: getChildScalar(root, "generator_version"),
+    symbols: getChildLists(root, "symbol").map(parseSymbol)
+  };
+}
+function parseSExpr(content) {
+  const tokens = tokenize(content);
+  const expressions = [];
+  let index = 0;
+  function parseList() {
+    const list = [];
+    index++;
+    while (index < tokens.length && tokens[index] !== ")") {
+      if (tokens[index] === "(") {
+        list.push(parseList());
+      } else {
+        list.push(tokens[index]);
+        index++;
+      }
+    }
+    if (tokens[index] !== ")") {
+      throw new Error("Unterminated S-expression list");
+    }
+    index++;
+    return list;
+  }
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (token === "(") {
+      expressions.push(parseList());
+    } else if (token === ")") {
+      throw new Error("Unexpected ')' in S-expression");
+    } else if (token !== void 0) {
+      expressions.push(token);
+      index++;
+    }
+  }
+  return expressions;
+}
+function tokenize(content) {
+  const tokens = [];
+  let index = 0;
+  while (index < content.length) {
+    const char = content[index];
+    if (/\s/.test(char)) {
+      index++;
+      continue;
+    }
+    if (char === ";") {
+      while (index < content.length && content[index] !== "\n") index++;
+      continue;
+    }
+    if (char === "(" || char === ")") {
+      tokens.push(char);
+      index++;
+      continue;
+    }
+    if (char === '"') {
+      let value2 = "";
+      index++;
+      while (index < content.length) {
+        const current = content[index];
+        if (current === "\\") {
+          const next = content[index + 1];
+          if (next === void 0) {
+            throw new Error("Unterminated escape sequence in quoted string");
+          }
+          value2 += next;
+          index += 2;
+          continue;
+        }
+        if (current === '"') {
+          index++;
+          break;
+        }
+        value2 += current;
+        index++;
+      }
+      tokens.push(value2);
+      continue;
+    }
+    let value = "";
+    while (index < content.length && !/\s/.test(content[index]) && content[index] !== "(" && content[index] !== ")") {
+      value += content[index];
+      index++;
+    }
+    tokens.push(value);
+  }
+  return tokens;
+}
+function parseSymbol(expr) {
+  const name = getAtom(expr[1]) ?? "";
+  const subSymbols = getChildLists(expr, "symbol").map(parseSymbol);
+  const directPins = getChildLists(expr, "pin").map(parsePin);
+  return {
+    name,
+    properties: Object.fromEntries(
+      getChildLists(expr, "property").flatMap((property) => {
+        const key = getAtom(property[1]);
+        const value = getAtom(property[2]);
+        return key ? [[key, value ?? ""]] : [];
+      })
+    ),
+    pins: directPins,
+    polylines: getChildLists(expr, "polyline").map(parsePolyline),
+    rectangles: getChildLists(expr, "rectangle").map(parseRectangle),
+    circles: getChildLists(expr, "circle").map(parseCircle),
+    arcs: getChildLists(expr, "arc").map(parseArc),
+    texts: getChildLists(expr, "text").map(parseText),
+    subSymbols
+  };
+}
+function parsePin(expr) {
+  const at = getChildList(expr, "at");
+  const length = getChildScalar(expr, "length");
+  return {
+    electricalType: getAtom(expr[1]),
+    graphicStyle: getAtom(expr[2]),
+    at: at ? {
+      x: parseNumber(getAtom(at[1])),
+      y: parseNumber(getAtom(at[2])),
+      angle: parseNumber(getAtom(at[3]))
+    } : void 0,
+    length: length !== void 0 ? parseNumber(length) : void 0,
+    hidden: getChildScalar(expr, "hide") === "yes",
+    name: getChildScalar(expr, "name") ?? "",
+    number: getChildScalar(expr, "number") ?? "",
+    alternates: getChildLists(expr, "alternate").map(parseAlternate)
+  };
+}
+function parseAlternate(expr) {
+  return {
+    name: getAtom(expr[1]) ?? "",
+    electricalType: getAtom(expr[2]),
+    graphicStyle: getAtom(expr[3])
+  };
+}
+function parsePolyline(expr) {
+  const pts = getChildList(expr, "pts");
+  return {
+    points: pts ? getChildLists(pts, "xy").map(parseXy) : [],
+    stroke: parseStroke(getChildList(expr, "stroke")),
+    fill: parseFill(getChildList(expr, "fill"))
+  };
+}
+function parseRectangle(expr) {
+  return {
+    start: parsePoint(getChildList(expr, "start")),
+    end: parsePoint(getChildList(expr, "end")),
+    stroke: parseStroke(getChildList(expr, "stroke")),
+    fill: parseFill(getChildList(expr, "fill"))
+  };
+}
+function parseCircle(expr) {
+  return {
+    center: parsePoint(getChildList(expr, "center")),
+    radius: parseNumber(getChildScalar(expr, "radius")),
+    stroke: parseStroke(getChildList(expr, "stroke")),
+    fill: parseFill(getChildList(expr, "fill"))
+  };
+}
+function parseArc(expr) {
+  return {
+    start: parsePoint(getChildList(expr, "start")),
+    mid: parsePoint(getChildList(expr, "mid")),
+    end: parsePoint(getChildList(expr, "end")),
+    stroke: parseStroke(getChildList(expr, "stroke"))
+  };
+}
+function parseText(expr) {
+  const at = getChildList(expr, "at");
+  const effects = getChildList(expr, "effects");
+  const font = effects ? getChildList(effects, "font") : void 0;
+  const fontSize = font ? getChildList(font, "size") : void 0;
+  return {
+    text: getAtom(expr[1]) ?? "",
+    at: at ? {
+      x: parseNumber(getAtom(at[1])),
+      y: parseNumber(getAtom(at[2])),
+      angle: parseNumber(getAtom(at[3]))
+    } : { x: 0, y: 0, angle: 0 },
+    fontSize: fontSize ? Math.max(
+      parseNumber(getAtom(fontSize[1])),
+      parseNumber(getAtom(fontSize[2]))
+    ) : void 0
+  };
+}
+function parseStroke(expr) {
+  if (!expr) return {};
+  return {
+    width: parseNumber(getChildScalar(expr, "width")),
+    type: getChildScalar(expr, "type")
+  };
+}
+function parseFill(expr) {
+  if (!expr) return {};
+  return {
+    type: getChildScalar(expr, "type")
+  };
+}
+function parseXy(expr) {
+  return {
+    x: parseNumber(getAtom(expr[1])),
+    y: parseNumber(getAtom(expr[2]))
+  };
+}
+function parsePoint(expr) {
+  if (!expr) return { x: 0, y: 0 };
+  return {
+    x: parseNumber(getAtom(expr[1])),
+    y: parseNumber(getAtom(expr[2]))
+  };
+}
+function getChildScalar(expr, token) {
+  const child = getChildList(expr, token);
+  if (!child) return void 0;
+  return getAtom(child[1]);
+}
+function getChildList(expr, token) {
+  return getChildLists(expr, token)[0];
+}
+function getChildLists(expr, token) {
+  return expr.filter(
+    (child) => isList(child) && child[0] === token
+  );
+}
+function getAtom(expr) {
+  return typeof expr === "string" ? expr : void 0;
+}
+function isList(expr) {
+  return Array.isArray(expr);
+}
+function parseNumber(value) {
+  if (value === void 0) return 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
 // lib/types.ts
 var ConverterStage = class {
   constructor(ctx) {
@@ -3671,6 +3920,411 @@ var InitializeSchematicContextStage = class extends ConverterStage {
   }
 };
 
+// lib/stages/symbol-library/CollectSymbolLibrarySymbolsStage.ts
+var MAX_KICAD_SYMBOL_UNIT_TO_CJ = 1;
+var PREVIEW_COLUMNS = 6;
+var PREVIEW_CELL_WIDTH = 10;
+var PREVIEW_CELL_HEIGHT = 9.5;
+var PREVIEW_CELL_FILL_RATIO = 0.95;
+var DEFAULT_STROKE_COLOR = "rgb(132, 0, 0)";
+var DEFAULT_FILL_COLOR = "rgb(255, 255, 194)";
+var CollectSymbolLibrarySymbolsStage = class extends ConverterStage {
+  processedSymbols = /* @__PURE__ */ new Set();
+  previewIndex = 0;
+  step() {
+    if (!this.ctx.kicadSymbolLib) {
+      this.finished = true;
+      return false;
+    }
+    const symbols = [...this.ctx.kicadSymbolLib.symbols].sort((a, b) => {
+      const aFileName = this.getKicadSymbolExportFileName(a);
+      const bFileName = this.getKicadSymbolExportFileName(b);
+      return aFileName < bFileName ? -1 : aFileName > bFileName ? 1 : 0;
+    });
+    for (const symbol of symbols) {
+      if (!symbol.name || this.processedSymbols.has(symbol.name)) continue;
+      this.processSymbol(symbol);
+      this.processedSymbols.add(symbol.name);
+    }
+    this.finished = true;
+    return false;
+  }
+  processSymbol(symbol) {
+    const sourceComponentData = this.createSourceComponentData(symbol);
+    const sourceComponent = this.ctx.db.source_component.insert(sourceComponentData);
+    const pins = this.collectPins(symbol);
+    const seenPinNumbers = /* @__PURE__ */ new Set();
+    let unnamedPinIndex = 0;
+    const sourcePortIdByPinNumber = /* @__PURE__ */ new Map();
+    for (const pin of pins) {
+      const pinNumber = pin.number || `unnamed_${unnamedPinIndex++}`;
+      if (seenPinNumbers.has(pinNumber)) continue;
+      seenPinNumbers.add(pinNumber);
+      const sourcePortData = {
+        source_component_id: sourceComponent.source_component_id,
+        name: this.getPortName(pin, pinNumber),
+        ...this.getSourcePortPinMetadata(pinNumber)
+      };
+      const sourcePort = this.ctx.db.source_port.insert(sourcePortData);
+      sourcePortIdByPinNumber.set(pinNumber, sourcePort.source_port_id);
+    }
+    this.createSchematicPreview({
+      symbol,
+      pins,
+      sourceComponentId: sourceComponent.source_component_id,
+      sourcePortIdByPinNumber
+    });
+    if (this.ctx.stats) {
+      this.ctx.stats.components = (this.ctx.stats.components || 0) + 1;
+      this.ctx.stats.pads = (this.ctx.stats.pads || 0) + seenPinNumbers.size;
+    }
+  }
+  getKicadSymbolExportFileName(symbol) {
+    return `${symbol.name}_unit1.svg`;
+  }
+  collectPins(symbol) {
+    return [
+      ...symbol.pins,
+      ...symbol.subSymbols.flatMap((subSymbol) => this.collectPins(subSymbol))
+    ];
+  }
+  collectPolylines(symbol) {
+    return [
+      ...symbol.polylines,
+      ...symbol.subSymbols.flatMap(
+        (subSymbol) => this.collectPolylines(subSymbol)
+      )
+    ];
+  }
+  collectRectangles(symbol) {
+    return [
+      ...symbol.rectangles,
+      ...symbol.subSymbols.flatMap(
+        (subSymbol) => this.collectRectangles(subSymbol)
+      )
+    ];
+  }
+  collectCircles(symbol) {
+    return [
+      ...symbol.circles,
+      ...symbol.subSymbols.flatMap(
+        (subSymbol) => this.collectCircles(subSymbol)
+      )
+    ];
+  }
+  collectArcs(symbol) {
+    return [
+      ...symbol.arcs,
+      ...symbol.subSymbols.flatMap((subSymbol) => this.collectArcs(subSymbol))
+    ];
+  }
+  collectTexts(symbol) {
+    return [
+      ...symbol.texts,
+      ...symbol.subSymbols.flatMap((subSymbol) => this.collectTexts(subSymbol))
+    ];
+  }
+  createSchematicPreview(params) {
+    const { symbol, pins, sourceComponentId, sourcePortIdByPinNumber } = params;
+    const bounds = this.getPinBounds(pins);
+    const scale3 = this.getPreviewScale(bounds);
+    const size = {
+      width: Math.max(1, bounds.width * scale3),
+      height: Math.max(1, bounds.height * scale3)
+    };
+    const center = this.getPreviewCenter();
+    const schematicComponentData = {
+      source_component_id: sourceComponentId,
+      center,
+      size,
+      is_box_with_pins: false
+    };
+    const schematicComponent = this.ctx.db.schematic_component.insert(
+      schematicComponentData
+    );
+    for (const pin of pins) {
+      if (!pin.at) continue;
+      const pinNumber = pin.number || "";
+      const sourcePortId = sourcePortIdByPinNumber.get(pinNumber);
+      if (!sourcePortId) continue;
+      const schematicPortData = {
+        schematic_component_id: schematicComponent.schematic_component_id,
+        source_port_id: sourcePortId,
+        center: this.toSchematicPoint(pin.at, center, scale3),
+        facing_direction: rotationToDirection(pin.at.angle),
+        ...this.getSchematicPortPinMetadata(pinNumber)
+      };
+      this.ctx.db.schematic_port.insert(schematicPortData);
+    }
+    this.createSchematicPrimitives({
+      symbol,
+      schematicComponentId: schematicComponent.schematic_component_id,
+      origin: center,
+      scale: scale3
+    });
+  }
+  getPreviewCenter() {
+    const index = this.previewIndex++;
+    const column = index % PREVIEW_COLUMNS;
+    const row = Math.floor(index / PREVIEW_COLUMNS);
+    return {
+      x: (column - (PREVIEW_COLUMNS - 1) / 2) * PREVIEW_CELL_WIDTH,
+      y: -row * PREVIEW_CELL_HEIGHT
+    };
+  }
+  getPinBounds(pins) {
+    const pinsWithPositions = pins.filter((pin) => pin.at);
+    if (pinsWithPositions.length === 0) {
+      return { width: 15, height: 15 };
+    }
+    const xs = pinsWithPositions.map((pin) => pin.at.x);
+    const ys = pinsWithPositions.map((pin) => pin.at.y);
+    return {
+      width: Math.max(...xs) - Math.min(...xs) + 7.5,
+      height: Math.max(...ys) - Math.min(...ys) + 7.5
+    };
+  }
+  getPreviewScale(bounds) {
+    const scaleX = PREVIEW_CELL_WIDTH * PREVIEW_CELL_FILL_RATIO / Math.max(1, bounds.width);
+    const scaleY = PREVIEW_CELL_HEIGHT * PREVIEW_CELL_FILL_RATIO / Math.max(1, bounds.height);
+    return Math.min(MAX_KICAD_SYMBOL_UNIT_TO_CJ, scaleX, scaleY);
+  }
+  createSchematicPrimitives(params) {
+    const { symbol, schematicComponentId, origin, scale: scale3 } = params;
+    for (const polyline of this.collectPolylines(symbol)) {
+      this.createPolylinePrimitives(
+        polyline,
+        schematicComponentId,
+        origin,
+        scale3
+      );
+    }
+    for (const rectangle of this.collectRectangles(symbol)) {
+      const start = this.toSchematicPoint(rectangle.start, origin, scale3);
+      const end = this.toSchematicPoint(rectangle.end, origin, scale3);
+      const rectData = {
+        schematic_component_id: schematicComponentId,
+        center: {
+          x: (start.x + end.x) / 2,
+          y: (start.y + end.y) / 2
+        },
+        width: Math.abs(end.x - start.x),
+        height: Math.abs(end.y - start.y),
+        rotation: 0,
+        stroke_width: this.toStrokeWidth(rectangle.stroke?.width, scale3),
+        color: DEFAULT_STROKE_COLOR,
+        is_filled: this.isFilled(rectangle.fill?.type),
+        fill_color: this.isFilled(rectangle.fill?.type) ? DEFAULT_FILL_COLOR : void 0,
+        is_dashed: rectangle.stroke?.type === "dash"
+      };
+      this.ctx.db.schematic_rect.insert(rectData);
+    }
+    for (const circle of this.collectCircles(symbol)) {
+      const circleData = {
+        schematic_component_id: schematicComponentId,
+        center: this.toSchematicPoint(circle.center, origin, scale3),
+        radius: circle.radius * scale3,
+        stroke_width: this.toStrokeWidth(circle.stroke?.width, scale3),
+        color: DEFAULT_STROKE_COLOR,
+        is_filled: this.isFilled(circle.fill?.type),
+        fill_color: this.isFilled(circle.fill?.type) ? DEFAULT_FILL_COLOR : void 0,
+        is_dashed: circle.stroke?.type === "dash"
+      };
+      this.ctx.db.schematic_circle.insert(circleData);
+    }
+    for (const arc of this.collectArcs(symbol)) {
+      const arcGeometry = this.getArcGeometry(arc, origin, scale3);
+      if (!arcGeometry) {
+        const pathData = {
+          schematic_component_id: schematicComponentId,
+          points: [arc.start, arc.mid, arc.end].map(
+            (point) => this.toSchematicPoint(point, origin, scale3)
+          ),
+          stroke_width: this.toStrokeWidth(arc.stroke?.width, scale3),
+          stroke_color: DEFAULT_STROKE_COLOR
+        };
+        this.ctx.db.schematic_path.insert(pathData);
+        continue;
+      }
+      const arcData = {
+        schematic_component_id: schematicComponentId,
+        ...arcGeometry,
+        stroke_width: this.toStrokeWidth(arc.stroke?.width, scale3),
+        color: DEFAULT_STROKE_COLOR,
+        is_dashed: arc.stroke?.type === "dash"
+      };
+      this.ctx.db.schematic_arc.insert(arcData);
+    }
+    for (const text of this.collectTexts(symbol)) {
+      if (!text.text) continue;
+      const textData = {
+        schematic_component_id: schematicComponentId,
+        text: text.text,
+        font_size: Math.max(0.1, (text.fontSize ?? 1.27) * scale3),
+        position: this.toSchematicPoint(text.at, origin, scale3),
+        rotation: -text.at.angle,
+        anchor: "center",
+        color: DEFAULT_STROKE_COLOR
+      };
+      this.ctx.db.schematic_text.insert(textData);
+    }
+  }
+  createPolylinePrimitives(polyline, schematicComponentId, origin, scale3) {
+    if (polyline.points.length < 2) return;
+    if (this.isFilled(polyline.fill?.type) && polyline.points.length >= 3) {
+      const pathData = {
+        schematic_component_id: schematicComponentId,
+        points: polyline.points.map(
+          (point) => this.toSchematicPoint(point, origin, scale3)
+        ),
+        stroke_width: this.toStrokeWidth(polyline.stroke?.width, scale3),
+        stroke_color: DEFAULT_STROKE_COLOR,
+        is_filled: true,
+        fill_color: DEFAULT_FILL_COLOR
+      };
+      this.ctx.db.schematic_path.insert(pathData);
+    }
+    for (let index = 1; index < polyline.points.length; index++) {
+      const start = this.toSchematicPoint(
+        polyline.points[index - 1],
+        origin,
+        scale3
+      );
+      const end = this.toSchematicPoint(polyline.points[index], origin, scale3);
+      const lineData = {
+        schematic_component_id: schematicComponentId,
+        x1: start.x,
+        y1: start.y,
+        x2: end.x,
+        y2: end.y,
+        stroke_width: this.toStrokeWidth(polyline.stroke?.width, scale3),
+        color: DEFAULT_STROKE_COLOR,
+        is_dashed: polyline.stroke?.type === "dash"
+      };
+      this.ctx.db.schematic_line.insert(lineData);
+    }
+  }
+  toSchematicPoint(point, origin = { x: 0, y: 0 }, scale3 = MAX_KICAD_SYMBOL_UNIT_TO_CJ) {
+    return {
+      x: origin.x + point.x * scale3,
+      y: origin.y + point.y * scale3
+    };
+  }
+  toStrokeWidth(width, scale3) {
+    if (!width) return null;
+    return Math.max(0.01, width * scale3);
+  }
+  isFilled(fillType) {
+    return fillType !== void 0 && fillType !== "none";
+  }
+  getArcGeometry(arc, origin, scale3) {
+    const start = this.toSchematicPoint(arc.start, origin, scale3);
+    const mid = this.toSchematicPoint(arc.mid, origin, scale3);
+    const end = this.toSchematicPoint(arc.end, origin, scale3);
+    const denominator = 2 * (start.x * (mid.y - end.y) + mid.x * (end.y - start.y) + end.x * (start.y - mid.y));
+    if (Math.abs(denominator) < 1e-9) return null;
+    const startLen = start.x ** 2 + start.y ** 2;
+    const midLen = mid.x ** 2 + mid.y ** 2;
+    const endLen = end.x ** 2 + end.y ** 2;
+    const center = {
+      x: (startLen * (mid.y - end.y) + midLen * (end.y - start.y) + endLen * (start.y - mid.y)) / denominator,
+      y: (startLen * (end.x - mid.x) + midLen * (start.x - end.x) + endLen * (mid.x - start.x)) / denominator
+    };
+    const radius = Math.hypot(start.x - center.x, start.y - center.y);
+    const startAngleDegrees = this.getAngleDegrees(start, center);
+    const endAngleDegrees = this.getAngleDegrees(end, center);
+    const cross = (mid.x - start.x) * (end.y - mid.y) - (mid.y - start.y) * (end.x - mid.x);
+    return {
+      center,
+      radius,
+      start_angle_degrees: startAngleDegrees,
+      end_angle_degrees: endAngleDegrees,
+      direction: cross >= 0 ? "counterclockwise" : "clockwise"
+    };
+  }
+  getAngleDegrees(point, center) {
+    return Math.atan2(point.y - center.y, point.x - center.x) * 180 / Math.PI;
+  }
+  getManufacturerPartNumber(symbol) {
+    return symbol.properties["Manufacturer Part Number"] || symbol.properties["MPN"] || symbol.properties["P/N"] || symbol.properties.Value || void 0;
+  }
+  createSourceComponentData(symbol) {
+    const base = {
+      name: symbol.name,
+      manufacturer_part_number: this.getManufacturerPartNumber(symbol)
+    };
+    const ftype = this.inferFtype(symbol);
+    switch (ftype) {
+      case "simple_resistor":
+        return { ...base, ftype, resistance: 0 };
+      case "simple_capacitor":
+        return { ...base, ftype, capacitance: 0 };
+      case "simple_inductor":
+        return { ...base, ftype, inductance: 0 };
+      case "simple_transistor":
+        return { ...base, ftype, transistor_type: "npn" };
+      case "simple_led":
+      case "simple_diode":
+      case "simple_chip":
+        return { ...base, ftype };
+    }
+  }
+  inferFtype(symbol) {
+    const name = symbol.name.toLowerCase();
+    const reference = symbol.properties.Reference ?? "";
+    if (name === "r" || name.startsWith("r_") || reference.startsWith("R")) {
+      return "simple_resistor";
+    }
+    if (name === "c" || name.startsWith("c_") || reference.startsWith("C")) {
+      return "simple_capacitor";
+    }
+    if (name === "l" || name.startsWith("l_") || reference.startsWith("L")) {
+      return "simple_inductor";
+    }
+    if (name.includes("led") || reference.startsWith("LED")) {
+      return "simple_led";
+    }
+    if (name.startsWith("d_") || reference.startsWith("D")) {
+      return "simple_diode";
+    }
+    if (name.startsWith("q_") || reference.startsWith("Q")) {
+      return "simple_transistor";
+    }
+    return "simple_chip";
+  }
+  getPortName(pin, pinNumber) {
+    if (pin.name) return pin.name;
+    if (/^\d+$/.test(pinNumber)) return `pin${Number(pinNumber)}`;
+    return pinNumber;
+  }
+  getSourcePortPinMetadata(pinNumber) {
+    if (/^\d+$/.test(pinNumber)) {
+      return { pin_number: Number(pinNumber) };
+    }
+    return { port_hints: [pinNumber] };
+  }
+  getSchematicPortPinMetadata(pinNumber) {
+    if (/^\d+$/.test(pinNumber)) {
+      return { pin_number: Number(pinNumber) };
+    }
+    return { display_pin_label: pinNumber };
+  }
+};
+
+// lib/stages/symbol-library/InitializeSymbolLibraryContextStage.ts
+var InitializeSymbolLibraryContextStage = class extends ConverterStage {
+  step() {
+    if (!this.ctx.kicadSymbolLib) {
+      this.finished = true;
+      return false;
+    }
+    this.ctx.warnings = this.ctx.warnings || [];
+    this.ctx.stats = this.ctx.stats || {};
+    this.finished = true;
+    return false;
+  }
+};
+
 // lib/KicadToCircuitJsonConverter.ts
 var KicadToCircuitJsonConverter = class {
   fsMap = {};
@@ -3697,14 +4351,22 @@ var KicadToCircuitJsonConverter = class {
   initializePipeline() {
     const pcbFile = this._findFileWithExtension(".kicad_pcb");
     const schFile = this._findFileWithExtension(".kicad_sch");
+    const symbolLibFile = this._findFileWithExtension(".kicad_sym");
     this.ctx = {
       db: cju([]),
       kicadPcb: pcbFile ? parseKicadPcb(this.fsMap[pcbFile]) : void 0,
       kicadSch: schFile ? parseKicadSch(this.fsMap[schFile]) : void 0,
+      kicadSymbolLib: symbolLibFile ? parseKicadSymbolLib(this.fsMap[symbolLibFile]) : void 0,
       warnings: [],
       stats: {}
     };
     this.pipeline = [];
+    if (this.ctx.kicadSymbolLib) {
+      this.pipeline.push(
+        new InitializeSymbolLibraryContextStage(this.ctx),
+        new CollectSymbolLibrarySymbolsStage(this.ctx)
+      );
+    }
     if (this.ctx.kicadSch) {
       this.pipeline.push(
         new InitializeSchematicContextStage(this.ctx),
@@ -3751,46 +4413,7 @@ var KicadToCircuitJsonConverter = class {
       this.initializePipeline();
       this.runUntilFinished();
     }
-    const elements = [];
-    const tableNames = [
-      "source_component",
-      "source_port",
-      "source_net",
-      "source_trace",
-      "schematic_component",
-      "schematic_port",
-      "schematic_trace",
-      "schematic_net_label",
-      "pcb_component",
-      "pcb_port",
-      "pcb_smtpad",
-      "pcb_plated_hole",
-      "pcb_hole",
-      "pcb_trace",
-      "pcb_via",
-      "pcb_copper_pour",
-      "pcb_board",
-      "pcb_cutout",
-      "pcb_copper_text",
-      "pcb_silkscreen_text",
-      "pcb_silkscreen_path",
-      "pcb_fabrication_note_text",
-      "pcb_fabrication_note_path",
-      "pcb_fabrication_note_rect",
-      "pcb_courtyard_rect",
-      "pcb_courtyard_outline",
-      "pcb_courtyard_circle"
-    ];
-    for (const tableName of tableNames) {
-      const table = this.ctx.db[tableName];
-      if (table && typeof table.list === "function") {
-        const items = table.list();
-        if (items && Array.isArray(items)) {
-          elements.push(...items);
-        }
-      }
-    }
-    return elements;
+    return this.ctx.db.toArray();
   }
   getOutputString() {
     return JSON.stringify(this.getOutput(), null, 2);
@@ -3809,11 +4432,13 @@ export {
   CollectNetsStage,
   CollectSchematicTracesStage,
   CollectSourceTracesStage,
+  CollectSymbolLibrarySymbolsStage,
   CollectTracesStage,
   CollectViasStage,
   CollectZonesStage,
   ConverterStage,
   InitializePcbContextStage,
   InitializeSchematicContextStage,
+  InitializeSymbolLibraryContextStage,
   KicadToCircuitJsonConverter
 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "kicad-to-circuit-json",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.78",
+  "version": "0.0.80",
   "files": [
     "dist"
   ],
@@ -35,7 +35,7 @@
     "kicadts": "^0.0.43",
     "react": "^19.2.0",
     "react-dom": "^19.2.5",
-    "tscircuit": "^0.0.1792",
+    "tscircuit": "^0.0.1825",
     "tsup": "^8.5.0",
     "vercel": "^50.42.0",
     "vite": "^8.0.8"