altium-to-circuit-json 0.0.2

package/dist/index.js

@@ -0,0 +1,1174 @@
+// lib/convert-altium-pcb-doc-to-circuit-json.ts
+import {
+  AltiumArcRecord,
+  AltiumFillRecord,
+  AltiumPadRecord,
+  AltiumTextRecord,
+  AltiumTrackRecord,
+  AltiumViaRecord,
+  getAltiumBounds,
+  getPcbLayerStack,
+  parseAltiumMeasurementToMils
+} from "altiumts";
+var MILS_TO_MILLIMETERS = 0.0254;
+var BOARD_ID = "pcb_board_altium";
+var BOARD_GRAPHICS_COMPONENT_ID = "pcb_component_altium_board_graphics";
+function convertAltiumPcbDocToCircuitJson(document, options = {}) {
+  const elements = [];
+  if (options.includeBoardOutline !== false) {
+    elements.push(createBoard(document));
+    for (const [index, cutout] of document.boardGeometry.cutouts.entries()) {
+      if (cutout.outline.points.length < 3) continue;
+      elements.push({
+        type: "pcb_cutout",
+        pcb_cutout_id: `pcb_cutout_altium_${index}`,
+        pcb_board_id: BOARD_ID,
+        shape: "polygon",
+        points: cutout.outline.points.map(toMillimeterPoint)
+      });
+    }
+  }
+  if (options.includeComponents !== false) {
+    for (const [index, component] of document.components.entries()) {
+      const position = component.position;
+      if (!position) continue;
+      const bounds = document.getComponentBounds(component);
+      elements.push({
+        type: "pcb_component",
+        pcb_component_id: componentId(index),
+        source_component_id: `source_component_altium_${index}`,
+        center: toMillimeterPoint(position),
+        width: milsToMillimeters(
+          bounds ? bounds.maxX - bounds.minX : component.heightMils ?? 20
+        ),
+        height: milsToMillimeters(
+          bounds ? bounds.maxY - bounds.minY : component.heightMils ?? 20
+        ),
+        layer: component.side === "bottom" ? "bottom" : "top",
+        rotation: component.rotation,
+        position_mode: "none",
+        obstructs_within_bounds: false
+      });
+    }
+  }
+  for (const [index, record] of document.records.entries()) {
+    if (record instanceof AltiumPadRecord && options.includePads !== false) {
+      const pad = convertPad(record, index);
+      if (pad) elements.push(pad);
+      continue;
+    }
+    if (record instanceof AltiumTrackRecord) {
+      if (isOverlayLayer(record.layer)) {
+        if (options.includeSilkscreen === false) continue;
+        const line = convertSilkscreenLine(record, index);
+        if (line) elements.push(line);
+      } else if (options.includeTraces !== false) {
+        const trace = convertTrack(record, index);
+        if (trace) elements.push(trace);
+      }
+      continue;
+    }
+    if (record instanceof AltiumViaRecord && options.includeVias !== false) {
+      const via = convertVia(record, index);
+      if (via) elements.push(via);
+      continue;
+    }
+    if (options.includeSilkscreen === false || !isOverlayLayer(getLayer(record))) {
+      continue;
+    }
+    if (record instanceof AltiumArcRecord) {
+      const path = convertSilkscreenArc(record, index);
+      if (path) elements.push(path);
+    } else if (record instanceof AltiumFillRecord) {
+      const rect = convertSilkscreenFill(record, index);
+      if (rect) elements.push(rect);
+    } else if (record instanceof AltiumTextRecord) {
+      const text = convertSilkscreenText(record, index);
+      if (text) elements.push(text);
+    }
+  }
+  return elements;
+}
+function createBoard(document) {
+  const outline = document.boardGeometry.outline.points.map(toMillimeterPoint);
+  const bounds = getAltiumBounds(document.boardGeometry.outline.points) ?? getFallbackPcbBounds(document.records);
+  const width = Math.max(milsToMillimeters(bounds.maxX - bounds.minX), 0.1);
+  const height = Math.max(milsToMillimeters(bounds.maxY - bounds.minY), 0.1);
+  const numLayers = document.board ? Math.max(
+    getPcbLayerStack(document.board).entries.filter(
+      (entry) => Boolean(mapCopperLayer(entry.name ?? entry.layerId))
+    ).length,
+    2
+  ) : 2;
+  return {
+    type: "pcb_board",
+    pcb_board_id: BOARD_ID,
+    center: {
+      x: milsToMillimeters((bounds.minX + bounds.maxX) / 2),
+      y: milsToMillimeters((bounds.minY + bounds.maxY) / 2)
+    },
+    width,
+    height,
+    ...outline.length >= 3 ? { shape: "polygon", outline } : {},
+    thickness: 1.6,
+    num_layers: numLayers,
+    material: "fr4"
+  };
+}
+function getFallbackPcbBounds(records) {
+  const points = [];
+  for (const record of records) {
+    if (record instanceof AltiumPadRecord || record instanceof AltiumViaRecord) {
+      if (record.position) points.push(record.position);
+    } else if (record instanceof AltiumTrackRecord) {
+      if (record.start) points.push(record.start);
+      if (record.end) points.push(record.end);
+    }
+  }
+  return getAltiumBounds(points) ?? { minX: 0, minY: 0, maxX: 1e3, maxY: 800 };
+}
+function convertTrack(record, index) {
+  const start = record.start;
+  const end = record.end;
+  const layer = mapCopperLayer(record.layer);
+  if (!start || !end || !layer) return void 0;
+  const width = milsToMillimeters(record.widthMils ?? 4);
+  return {
+    type: "pcb_trace",
+    pcb_trace_id: `pcb_trace_altium_${index}`,
+    should_round_corners: true,
+    route: [
+      { route_type: "wire", ...toMillimeterPoint(start), width, layer },
+      { route_type: "wire", ...toMillimeterPoint(end), width, layer }
+    ]
+  };
+}
+function convertVia(record, index) {
+  if (!record.position) return void 0;
+  const startLayer = mapCopperLayer(record.startLayer) ?? "top";
+  const endLayer = mapCopperLayer(record.endLayer) ?? "bottom";
+  const layers = startLayer === endLayer ? [startLayer] : [startLayer, endLayer];
+  const outerDiameter = milsToMillimeters(record.diameterMils ?? 20);
+  return {
+    type: "pcb_via",
+    pcb_via_id: `pcb_via_altium_${index}`,
+    ...toMillimeterPoint(record.position),
+    outer_diameter: outerDiameter,
+    hole_diameter: milsToMillimeters(
+      record.holeSizeMils ?? (record.diameterMils ?? 20) * 0.45
+    ),
+    layers,
+    is_tented: record.tentedTop === true && record.tentedBottom === true
+  };
+}
+function convertPad(record, index) {
+  const position = record.position;
+  const size = record.size;
+  if (!position || !size) return void 0;
+  const x = milsToMillimeters(position.x);
+  const y = milsToMillimeters(position.y);
+  const width = milsToMillimeters(size.width);
+  const height = milsToMillimeters(size.height);
+  const holeDiameter = milsToMillimeters(record.holeSizeMils ?? 0);
+  const shape = normalizeShape(record.shape);
+  const id = `altium_${index}`;
+  if (record.plated === false && holeDiameter > 0) {
+    return {
+      type: "pcb_hole",
+      pcb_hole_id: `pcb_hole_${id}`,
+      hole_shape: "circle",
+      hole_diameter: holeDiameter,
+      x,
+      y
+    };
+  }
+  if (record.behavior === "through-hole" || holeDiameter > 0) {
+    const slotLengthMils = getMeasurement(record, "SLOTLENGTH");
+    const holeWidthMils = record.holeWidthMils ?? record.holeSizeMils;
+    const isSlot = normalizeShape(record.holeType).includes("SLOT") || (slotLengthMils ?? 0) > (record.holeSizeMils ?? 0) || (holeWidthMils ?? 0) > (record.holeSizeMils ?? 0);
+    const layers = ["top", "bottom"];
+    if (isSlot) {
+      const holeWidth = milsToMillimeters(
+        Math.max(
+          slotLengthMils ?? holeWidthMils ?? record.holeSizeMils ?? 1,
+          1
+        )
+      );
+      const holeHeight = Math.max(holeDiameter, MILS_TO_MILLIMETERS);
+      if (isRectangularShape(shape)) {
+        const rotated = record.holeRotation !== 0 || record.rotation !== 0;
+        return {
+          type: "pcb_plated_hole",
+          pcb_plated_hole_id: `pcb_plated_hole_${id}`,
+          shape: rotated ? "rotated_pill_hole_with_rect_pad" : "pill_hole_with_rect_pad",
+          hole_shape: rotated ? "rotated_pill" : "pill",
+          pad_shape: "rect",
+          hole_width: holeWidth,
+          hole_height: holeHeight,
+          ...rotated ? { hole_ccw_rotation: record.holeRotation } : {},
+          rect_pad_width: width,
+          rect_pad_height: height,
+          ...rotated ? { rect_ccw_rotation: record.rotation } : {},
+          hole_offset_x: 0,
+          hole_offset_y: 0,
+          x,
+          y,
+          layers
+        };
+      }
+      return {
+        type: "pcb_plated_hole",
+        pcb_plated_hole_id: `pcb_plated_hole_${id}`,
+        shape: "pill",
+        outer_width: width,
+        outer_height: height,
+        hole_width: holeWidth,
+        hole_height: holeHeight,
+        ccw_rotation: record.holeRotation || record.rotation,
+        x,
+        y,
+        layers
+      };
+    }
+    if (isRectangularShape(shape)) {
+      return {
+        type: "pcb_plated_hole",
+        pcb_plated_hole_id: `pcb_plated_hole_${id}`,
+        shape: "circular_hole_with_rect_pad",
+        hole_shape: "circle",
+        pad_shape: "rect",
+        hole_diameter: Math.max(holeDiameter, MILS_TO_MILLIMETERS),
+        rect_pad_width: width,
+        rect_pad_height: height,
+        rect_border_radius: shape.includes("ROUNDRECT") ? Math.min(width, height) * 0.18 : 0,
+        rect_ccw_rotation: record.rotation,
+        hole_offset_x: 0,
+        hole_offset_y: 0,
+        x,
+        y,
+        layers
+      };
+    }
+    if (shape.includes("OCTAGON")) {
+      return {
+        type: "pcb_plated_hole",
+        pcb_plated_hole_id: `pcb_plated_hole_${id}`,
+        shape: "hole_with_polygon_pad",
+        hole_shape: "circle",
+        hole_diameter: Math.max(holeDiameter, MILS_TO_MILLIMETERS),
+        pad_outline: createOctagonPoints(x, y, width, height, record.rotation),
+        hole_offset_x: 0,
+        hole_offset_y: 0,
+        x,
+        y,
+        layers
+      };
+    }
+    if (shape === "ROUND" || shape === "CIRCLE" || shape === "OVAL") {
+      if (Math.abs(width - height) >= 1e-4) {
+        return {
+          type: "pcb_plated_hole",
+          pcb_plated_hole_id: `pcb_plated_hole_${id}`,
+          shape: "pill",
+          outer_width: width,
+          outer_height: height,
+          hole_width: Math.max(holeDiameter, MILS_TO_MILLIMETERS),
+          hole_height: Math.max(holeDiameter, MILS_TO_MILLIMETERS),
+          ccw_rotation: record.rotation,
+          x,
+          y,
+          layers
+        };
+      }
+    }
+    return {
+      type: "pcb_plated_hole",
+      pcb_plated_hole_id: `pcb_plated_hole_${id}`,
+      shape: "circle",
+      outer_diameter: Math.max(width, height),
+      hole_diameter: Math.max(holeDiameter, MILS_TO_MILLIMETERS),
+      x,
+      y,
+      layers
+    };
+  }
+  const layer = mapCopperLayer(record.layer);
+  if (!layer) return void 0;
+  const base = {
+    type: "pcb_smtpad",
+    pcb_smtpad_id: `pcb_smtpad_${id}`,
+    x,
+    y,
+    layer,
+    soldermask_margin: record.solderMaskExpansionMils === void 0 ? void 0 : milsToMillimeters(record.solderMaskExpansionMils)
+  };
+  if (shape.includes("OCTAGON")) {
+    return {
+      ...base,
+      shape: "polygon",
+      points: createOctagonPoints(x, y, width, height, record.rotation)
+    };
+  }
+  if (shape === "ROUND" || shape === "CIRCLE" || shape === "OVAL") {
+    if (Math.abs(width - height) < 1e-4) {
+      return { ...base, shape: "circle", radius: width / 2 };
+    }
+    return record.rotation === 0 ? {
+      ...base,
+      shape: "pill",
+      width,
+      height,
+      radius: Math.min(width, height) / 2
+    } : {
+      ...base,
+      shape: "rotated_pill",
+      width,
+      height,
+      radius: Math.min(width, height) / 2,
+      ccw_rotation: record.rotation
+    };
+  }
+  const cornerRadius = shape.includes("ROUNDRECT") ? Math.min(width, height) * 0.18 : void 0;
+  return record.rotation === 0 ? { ...base, shape: "rect", width, height, corner_radius: cornerRadius } : {
+    ...base,
+    shape: "rotated_rect",
+    width,
+    height,
+    corner_radius: cornerRadius,
+    ccw_rotation: record.rotation
+  };
+}
+function convertSilkscreenLine(record, index) {
+  if (!record.start || !record.end) return void 0;
+  return {
+    type: "pcb_silkscreen_line",
+    pcb_silkscreen_line_id: `pcb_silkscreen_line_altium_${index}`,
+    pcb_component_id: pcbComponentIdForRecord(record),
+    stroke_width: milsToMillimeters(record.widthMils ?? 4),
+    ...withNumberedPoints(record.start, record.end),
+    layer: mapOverlayLayer(record.layer)
+  };
+}
+function convertSilkscreenArc(record, index) {
+  if (!record.center || !record.radiusMils) return void 0;
+  const points = approximateArc(
+    record.center,
+    record.radiusMils,
+    record.startAngle,
+    record.endAngle
+  );
+  return {
+    type: "pcb_silkscreen_path",
+    pcb_silkscreen_path_id: `pcb_silkscreen_path_altium_${index}`,
+    pcb_component_id: pcbComponentIdForRecord(record),
+    route: points.map(toMillimeterPoint),
+    stroke_width: milsToMillimeters(record.widthMils ?? 4),
+    layer: mapOverlayLayer(record.layer)
+  };
+}
+function convertSilkscreenFill(record, index) {
+  if (!record.bounds) return void 0;
+  const width = milsToMillimeters(record.bounds.maxX - record.bounds.minX);
+  const height = milsToMillimeters(record.bounds.maxY - record.bounds.minY);
+  return {
+    type: "pcb_silkscreen_rect",
+    pcb_silkscreen_rect_id: `pcb_silkscreen_rect_altium_${index}`,
+    pcb_component_id: pcbComponentIdForRecord(record),
+    center: {
+      x: milsToMillimeters((record.bounds.minX + record.bounds.maxX) / 2),
+      y: milsToMillimeters((record.bounds.minY + record.bounds.maxY) / 2)
+    },
+    width,
+    height,
+    stroke_width: Math.min(width, height),
+    is_filled: true,
+    has_stroke: false,
+    ccw_rotation: record.rotation,
+    layer: mapOverlayLayer(record.layer)
+  };
+}
+function convertSilkscreenText(record, index) {
+  const text = decodeAltiumWideString(record.getDecoded("WIDESTRING")) || record.getDecoded("TEXT") || record.text;
+  if (!record.position || !text) return void 0;
+  return {
+    type: "pcb_silkscreen_text",
+    pcb_silkscreen_text_id: `pcb_silkscreen_text_altium_${index}`,
+    pcb_component_id: pcbComponentIdForRecord(record),
+    text,
+    font: "tscircuit2024",
+    font_size: milsToMillimeters(record.heightMils ?? 30),
+    anchor_position: toMillimeterPoint(record.position),
+    anchor_alignment: mapTextAnchor(record.justification),
+    ccw_rotation: record.rotation,
+    layer: mapOverlayLayer(record.layer),
+    is_mirrored: record.mirrored
+  };
+}
+function decodeAltiumWideString(raw) {
+  if (!raw) return "";
+  if (!/^\d+(?:,\d+)*$/u.test(raw)) return raw;
+  try {
+    return String.fromCodePoint(...raw.split(",").map(Number));
+  } catch {
+    return raw;
+  }
+}
+function pcbComponentIdForRecord(record) {
+  const index = record.getNumber("COMPONENT");
+  return index === void 0 || index < 0 ? BOARD_GRAPHICS_COMPONENT_ID : componentId(index);
+}
+function componentId(index) {
+  return `pcb_component_altium_${index}`;
+}
+function mapTextAnchor(justification) {
+  const normalized = justification?.replace(/[\s_-]+/gu, "").toUpperCase();
+  if (normalized?.includes("CENTER")) return "bottom_center";
+  if (normalized?.includes("RIGHT")) return "bottom_right";
+  if (normalized?.includes("LEFT")) return "bottom_left";
+  return "center";
+}
+function mapCopperLayer(layer) {
+  const normalized = normalizeLayer(layer);
+  if (normalized === "TOP" || normalized === "TOPLAYER") return "top";
+  if (normalized === "BOTTOM" || normalized === "BOTTOMLAYER") return "bottom";
+  const innerMatch = /^(?:MID|MIDLAYER|INTERNALPLANE)(\d+)$/u.exec(normalized);
+  if (!innerMatch?.[1]) return void 0;
+  const innerNumber = Math.min(Math.max(Number(innerMatch[1]), 1), 8);
+  return `inner${innerNumber}`;
+}
+function isOverlayLayer(layer) {
+  const normalized = normalizeLayer(layer);
+  return normalized === "TOPOVERLAY" || normalized === "BOTTOMOVERLAY";
+}
+function mapOverlayLayer(layer) {
+  return normalizeLayer(layer) === "BOTTOMOVERLAY" ? "bottom" : "top";
+}
+function getLayer(record) {
+  return record.getDecoded("LAYER");
+}
+function normalizeLayer(layer) {
+  return (layer ?? "").replace(/[\s_.-]+/gu, "").toUpperCase();
+}
+function normalizeShape(shape) {
+  return (shape ?? "ROUND").replace(/[\s_-]+/gu, "").toUpperCase();
+}
+function isRectangularShape(shape) {
+  return shape.includes("RECT") || shape === "SQUARE";
+}
+function getMeasurement(record, key) {
+  return parseAltiumMeasurementToMils(record.getCaseInsensitive(key));
+}
+function milsToMillimeters(value) {
+  return value * MILS_TO_MILLIMETERS;
+}
+function toMillimeterPoint(point) {
+  return { x: milsToMillimeters(point.x), y: milsToMillimeters(point.y) };
+}
+function withNumberedPoints(start, end) {
+  return {
+    x1: milsToMillimeters(start.x),
+    y1: milsToMillimeters(start.y),
+    x2: milsToMillimeters(end.x),
+    y2: milsToMillimeters(end.y)
+  };
+}
+function approximateArc(center, radius, startAngle, endAngle) {
+  const sweep = endAngle - startAngle || 360;
+  const segments = Math.max(8, Math.ceil(Math.abs(sweep) / 7.5));
+  return Array.from({ length: segments + 1 }, (_, index) => {
+    const angle = startAngle + sweep * index / segments;
+    const radians = angle * Math.PI / 180;
+    return {
+      x: center.x + Math.cos(radians) * radius,
+      y: center.y + Math.sin(radians) * radius
+    };
+  });
+}
+function createOctagonPoints(x, y, width, height, rotation) {
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const chamfer = Math.min(width, height) / 4;
+  const points = [
+    { x: -halfWidth + chamfer, y: -halfHeight },
+    { x: halfWidth - chamfer, y: -halfHeight },
+    { x: halfWidth, y: -halfHeight + chamfer },
+    { x: halfWidth, y: halfHeight - chamfer },
+    { x: halfWidth - chamfer, y: halfHeight },
+    { x: -halfWidth + chamfer, y: halfHeight },
+    { x: -halfWidth, y: halfHeight - chamfer },
+    { x: -halfWidth, y: -halfHeight + chamfer }
+  ];
+  const radians = rotation * Math.PI / 180;
+  return points.map((point) => ({
+    x: x + point.x * Math.cos(radians) - point.y * Math.sin(radians),
+    y: y + point.x * Math.sin(radians) + point.y * Math.cos(radians)
+  }));
+}
+
+// lib/convert-altium-sch-doc-to-circuit-json.ts
+import {
+  getSchematicRecordPoints
+} from "altiumts";
+var DEFAULT_SCHEMATIC_UNIT_SCALE = 0.1;
+var SCHEMATIC_SHEET_ID = "schematic_sheet_altium";
+function convertAltiumSchDocToCircuitJson(document, options = {}) {
+  const scale = options.schematicUnitScale ?? DEFAULT_SCHEMATIC_UNIT_SCALE;
+  if (!Number.isFinite(scale) || scale <= 0) {
+    throw new RangeError("schematicUnitScale must be a positive finite number");
+  }
+  const records = document.records;
+  const sheetRecord = records.find((record) => record.recordKind === "31");
+  const context = { document, records, scale, sheetRecord };
+  const elements = [
+    {
+      type: "schematic_sheet",
+      schematic_sheet_id: SCHEMATIC_SHEET_ID,
+      name: options.sheetName ?? "Altium schematic",
+      sheet_index: 0
+    }
+  ];
+  if (options.includeSheetBorder !== false) {
+    elements.push(createSheetBorder(sheetRecord, scale));
+  }
+  for (const [index, record] of records.entries()) {
+    if (!shouldRenderSchematicRecord(record, context)) continue;
+    const converted = convertSchematicRecord(record, index, context, options);
+    elements.push(...converted);
+  }
+  return elements;
+}
+function convertSchematicRecord(record, index, context, options) {
+  const kind = record.recordKind;
+  const scale = context.scale;
+  const color = altiumColorToCss(record.getCaseInsensitive("COLOR"), "#1f2937");
+  const strokeWidth = Math.max(
+    Number(record.getCaseInsensitive("LINEWIDTH") ?? 1) * scale,
+    0.05
+  );
+  if (kind === "27") {
+    const points = getSchematicRecordPoints(record).map(
+      (point) => scalePoint(point, scale)
+    );
+    if (points.length < 2) return [];
+    return [
+      {
+        type: "schematic_trace",
+        schematic_trace_id: `schematic_trace_altium_${index}`,
+        schematic_sheet_id: SCHEMATIC_SHEET_ID,
+        junctions: [],
+        edges: points.slice(1).map((point, pointIndex) => ({
+          from: points[pointIndex] ?? point,
+          to: point
+        }))
+      }
+    ];
+  }
+  if (kind === "6" || kind === "7") {
+    const points = getSchematicRecordPoints(record).map(
+      (point) => scalePoint(point, scale)
+    );
+    if (points.length < 2) return [];
+    return [
+      {
+        type: "schematic_path",
+        schematic_path_id: `schematic_path_altium_${index}`,
+        schematic_sheet_id: SCHEMATIC_SHEET_ID,
+        points,
+        stroke_width: strokeWidth,
+        stroke_color: color,
+        fill_color: kind === "7" ? altiumColorToCss(
+          record.getCaseInsensitive("AREACOLOR"),
+          "transparent"
+        ) : void 0,
+        is_filled: kind === "7",
+        is_dashed: false
+      }
+    ];
+  }
+  if (kind === "13") {
+    const location = getLocation(record);
+    const corner = getCorner(record);
+    if (!location || !corner) return [];
+    return [createLine(index, location, corner, color, strokeWidth, scale)];
+  }
+  if (kind === "10" || kind === "14") {
+    const rectangle = getRectangle(record);
+    if (!rectangle) return [];
+    return [
+      {
+        type: "schematic_rect",
+        schematic_rect_id: `schematic_rect_altium_${index}`,
+        schematic_sheet_id: SCHEMATIC_SHEET_ID,
+        center: scalePoint(
+          {
+            x: (rectangle.minX + rectangle.maxX) / 2,
+            y: (rectangle.minY + rectangle.maxY) / 2
+          },
+          scale
+        ),
+        width: (rectangle.maxX - rectangle.minX) * scale,
+        height: (rectangle.maxY - rectangle.minY) * scale,
+        rotation: 0,
+        stroke_width: strokeWidth,
+        color,
+        is_filled: record.getBoolean("ISSOLID") === true,
+        fill_color: altiumColorToCss(
+          record.getCaseInsensitive("AREACOLOR"),
+          "#ffffff"
+        ),
+        is_dashed: false
+      }
+    ];
+  }
+  if (kind === "8") {
+    const center = getLocation(record);
+    if (!center) return [];
+    const radiusX = getCoordinate(record, "RADIUS", 1);
+    const radiusY = getCoordinate(record, "SECONDARYRADIUS", radiusX);
+    if (Math.abs(radiusX - radiusY) < 1e-4) {
+      return [
+        {
+          type: "schematic_circle",
+          schematic_circle_id: `schematic_circle_altium_${index}`,
+          schematic_sheet_id: SCHEMATIC_SHEET_ID,
+          center: scalePoint(center, scale),
+          radius: radiusX * scale,
+          stroke_width: strokeWidth,
+          color,
+          is_filled: record.getBoolean("ISSOLID") === true,
+          fill_color: altiumColorToCss(
+            record.getCaseInsensitive("AREACOLOR"),
+            "#ffffff"
+          ),
+          is_dashed: false
+        }
+      ];
+    }
+    return [
+      {
+        type: "schematic_path",
+        schematic_path_id: `schematic_ellipse_altium_${index}`,
+        schematic_sheet_id: SCHEMATIC_SHEET_ID,
+        points: approximateEllipse(center, radiusX, radiusY).map(
+          (point) => scalePoint(point, scale)
+        ),
+        stroke_width: strokeWidth,
+        stroke_color: color,
+        fill_color: altiumColorToCss(
+          record.getCaseInsensitive("AREACOLOR"),
+          "#ffffff"
+        ),
+        is_filled: record.getBoolean("ISSOLID") === true,
+        is_dashed: false
+      }
+    ];
+  }
+  if (kind === "11" || kind === "12") {
+    const center = getLocation(record);
+    if (!center) return [];
+    return [
+      {
+        type: "schematic_arc",
+        schematic_arc_id: `schematic_arc_altium_${index}`,
+        schematic_sheet_id: SCHEMATIC_SHEET_ID,
+        center: scalePoint(center, scale),
+        radius: getCoordinate(record, "RADIUS", 1) * scale,
+        start_angle_degrees: Number(
+          record.getCaseInsensitive("STARTANGLE") ?? 0
+        ),
+        end_angle_degrees: Number(record.getCaseInsensitive("ENDANGLE") ?? 360),
+        direction: "counterclockwise",
+        stroke_width: strokeWidth,
+        color,
+        is_dashed: false
+      }
+    ];
+  }
+  if (kind === "2") {
+    return convertPin(record, index, context, options, color);
+  }
+  if (kind === "29") {
+    const location = getLocation(record);
+    if (!location) return [];
+    return [
+      {
+        type: "schematic_circle",
+        schematic_circle_id: `schematic_junction_altium_${index}`,
+        schematic_sheet_id: SCHEMATIC_SHEET_ID,
+        center: scalePoint(location, scale),
+        radius: Math.max(
+          Number(record.getCaseInsensitive("SIZE") ?? 1) * 0.18,
+          0.15
+        ),
+        color,
+        is_filled: true,
+        fill_color: color,
+        is_dashed: false
+      }
+    ];
+  }
+  if (kind === "22") {
+    const location = getLocation(record);
+    if (!location) return [];
+    const radius = 0.4 / scale;
+    return [
+      createLine(
+        index,
+        { x: location.x - radius, y: location.y - radius },
+        { x: location.x + radius, y: location.y + radius },
+        color,
+        0.1,
+        scale,
+        "a"
+      ),
+      createLine(
+        index,
+        { x: location.x + radius, y: location.y - radius },
+        { x: location.x - radius, y: location.y + radius },
+        color,
+        0.1,
+        scale,
+        "b"
+      )
+    ];
+  }
+  if (kind === "17") {
+    return convertPowerPort(record, index, context, options, color);
+  }
+  if (kind === "18") {
+    return convertPort(record, index, context, options, color);
+  }
+  if (kind === "4" || kind === "25" || kind === "34" || kind === "41") {
+    if (options.includeText === false) return [];
+    if (record.getBoolean("ISHIDDEN") && !options.includeHidden) return [];
+    const text = record.getDecoded("TEXT") ?? record.getDecoded("NAME") ?? record.getDecoded("DESIGNATOR");
+    const location = getLocation(record);
+    if (!text || !location) return [];
+    return [createText(record, index, text, location, color, context)];
+  }
+  if (kind === "28") {
+    const rectangle = getRectangle(record);
+    const text = decodeMultilineText(record.getDecoded("TEXT") ?? "");
+    if (!rectangle || !text || options.includeText === false) return [];
+    const rect = {
+      type: "schematic_rect",
+      schematic_rect_id: `schematic_text_frame_altium_${index}`,
+      schematic_sheet_id: SCHEMATIC_SHEET_ID,
+      center: scalePoint(
+        {
+          x: (rectangle.minX + rectangle.maxX) / 2,
+          y: (rectangle.minY + rectangle.maxY) / 2
+        },
+        scale
+      ),
+      width: (rectangle.maxX - rectangle.minX) * scale,
+      height: (rectangle.maxY - rectangle.minY) * scale,
+      rotation: 0,
+      stroke_width: strokeWidth,
+      color,
+      is_filled: false,
+      is_dashed: false
+    };
+    const textElement = createText(
+      record,
+      index,
+      text,
+      { x: rectangle.minX + 2, y: rectangle.maxY - 2 },
+      color,
+      context,
+      "top_left"
+    );
+    return [rect, textElement];
+  }
+  return [];
+}
+function convertPin(record, index, context, options, color) {
+  const location = getLocation(record);
+  if (!location) return [];
+  const pinConglomerate = record.getNumber("PINCONGLOMERATE");
+  const hidden = record.getBoolean("ISHIDDEN") || pinConglomerate !== void 0 && (pinConglomerate & 4) !== 0;
+  if (hidden && !options.includeHidden) return [];
+  const orientation = (pinConglomerate ?? Number(record.getCaseInsensitive("ORIENTATION") ?? 0)) & 3;
+  const direction = [
+    { x: 1, y: 0 },
+    { x: 0, y: 1 },
+    { x: -1, y: 0 },
+    { x: 0, y: -1 }
+  ][orientation] ?? { x: 1, y: 0 };
+  const length = Math.max(
+    Number(record.getCaseInsensitive("PINLENGTH") ?? 10),
+    1
+  );
+  const end = {
+    x: location.x + direction.x * length,
+    y: location.y + direction.y * length
+  };
+  const elements = [
+    createLine(index, location, end, color, 0.1, context.scale, "pin")
+  ];
+  if (options.includeText === false) return elements;
+  const name = record.getDecoded("NAME") ?? "";
+  const designator = record.getDecoded("DESIGNATOR") ?? "";
+  const showName = pinConglomerate === void 0 || (pinConglomerate & 8) !== 0;
+  const showDesignator = pinConglomerate === void 0 || (pinConglomerate & 16) !== 0;
+  const rotation = orientation === 1 || orientation === 3 ? 90 : 0;
+  const directionMatchesText = orientation === 0 || orientation === 1;
+  const nameAnchor = directionMatchesText ? "right" : "left";
+  const designatorAnchor = directionMatchesText ? "left" : "right";
+  const textOffset = 2;
+  if (showName && name) {
+    elements.push(
+      createDirectText(
+        `schematic_pin_name_altium_${index}`,
+        name,
+        {
+          x: location.x - direction.x * textOffset,
+          y: location.y - direction.y * textOffset
+        },
+        0.6,
+        color,
+        context.scale,
+        rotation,
+        nameAnchor
+      )
+    );
+  }
+  if (showDesignator && designator) {
+    elements.push(
+      createDirectText(
+        `schematic_pin_designator_altium_${index}`,
+        designator,
+        {
+          x: location.x + direction.x * textOffset,
+          y: location.y + direction.y * textOffset
+        },
+        0.6,
+        color,
+        context.scale,
+        rotation,
+        designatorAnchor
+      )
+    );
+  }
+  return elements;
+}
+function convertPowerPort(record, index, context, options, color) {
+  const location = getLocation(record);
+  if (!location) return [];
+  const points = [
+    { x: location.x, y: location.y },
+    { x: location.x - 5, y: location.y + 7 },
+    { x: location.x + 5, y: location.y + 7 }
+  ];
+  const elements = [
+    {
+      type: "schematic_path",
+      schematic_path_id: `schematic_power_port_altium_${index}`,
+      schematic_sheet_id: SCHEMATIC_SHEET_ID,
+      points: points.map((point) => scalePoint(point, context.scale)),
+      stroke_width: 0.1,
+      stroke_color: color,
+      fill_color: color,
+      is_filled: true,
+      is_dashed: false
+    }
+  ];
+  const text = record.getDecoded("TEXT") ?? record.getDecoded("NAME");
+  if (text && options.includeText !== false) {
+    elements.push(
+      createDirectText(
+        `schematic_power_port_text_altium_${index}`,
+        text,
+        { x: location.x + 7, y: location.y + 3 },
+        getFontSize(record, context),
+        color,
+        context.scale,
+        0,
+        "left"
+      )
+    );
+  }
+  return elements;
+}
+function convertPort(record, index, context, options, color) {
+  const location = getLocation(record);
+  if (!location) return [];
+  const width = Math.max(Number(record.getCaseInsensitive("WIDTH") ?? 16), 10);
+  const points = [
+    { x: location.x, y: location.y },
+    { x: location.x + width * 0.22, y: location.y + 5 },
+    { x: location.x + width, y: location.y + 5 },
+    { x: location.x + width, y: location.y - 5 },
+    { x: location.x + width * 0.22, y: location.y - 5 }
+  ];
+  const elements = [
+    {
+      type: "schematic_path",
+      schematic_path_id: `schematic_port_altium_${index}`,
+      schematic_sheet_id: SCHEMATIC_SHEET_ID,
+      points: points.map((point) => scalePoint(point, context.scale)),
+      stroke_width: 0.1,
+      stroke_color: color,
+      fill_color: "#ffffff",
+      is_filled: true,
+      is_dashed: false
+    }
+  ];
+  const name = record.getDecoded("NAME");
+  if (name && options.includeText !== false) {
+    elements.push(
+      createDirectText(
+        `schematic_port_text_altium_${index}`,
+        name,
+        { x: location.x + width / 2, y: location.y },
+        getFontSize(record, context),
+        color,
+        context.scale,
+        0,
+        "center"
+      )
+    );
+  }
+  return elements;
+}
+function createSheetBorder(sheetRecord, scale) {
+  const width = Math.max(
+    Number(sheetRecord?.getCaseInsensitive("CUSTOMX") ?? 1e3),
+    1
+  );
+  const height = Math.max(
+    Number(sheetRecord?.getCaseInsensitive("CUSTOMY") ?? 800),
+    1
+  );
+  return {
+    type: "schematic_rect",
+    schematic_rect_id: "schematic_rect_altium_sheet_border",
+    schematic_sheet_id: SCHEMATIC_SHEET_ID,
+    center: { x: width * scale / 2, y: height * scale / 2 },
+    width: width * scale,
+    height: height * scale,
+    rotation: 0,
+    stroke_width: 0.1,
+    color: "#334155",
+    is_filled: false,
+    is_dashed: false
+  };
+}
+function createLine(index, start, end, color, strokeWidth, scale, suffix = "line") {
+  return {
+    type: "schematic_line",
+    schematic_line_id: `schematic_line_altium_${index}_${suffix}`,
+    schematic_sheet_id: SCHEMATIC_SHEET_ID,
+    x1: start.x * scale,
+    y1: start.y * scale,
+    x2: end.x * scale,
+    y2: end.y * scale,
+    stroke_width: strokeWidth,
+    color,
+    is_dashed: false
+  };
+}
+function createText(record, index, text, location, color, context, anchorOverride) {
+  const positioning = getTextPositioning(record);
+  return createDirectText(
+    `schematic_text_altium_${index}`,
+    text,
+    location,
+    getFontSize(record, context),
+    color,
+    context.scale,
+    positioning.rotation,
+    anchorOverride ?? positioning.anchor
+  );
+}
+function createDirectText(id, text, location, fontSize, color, scale, rotation, anchor) {
+  return {
+    type: "schematic_text",
+    schematic_text_id: id,
+    schematic_sheet_id: SCHEMATIC_SHEET_ID,
+    text,
+    font_size: Math.max(fontSize * scale, 0.2),
+    position: scalePoint(location, scale),
+    rotation,
+    anchor,
+    color
+  };
+}
+function getFontSize(record, context) {
+  const fontId = Math.max(
+    Math.round(Number(record.getCaseInsensitive("FONTID") ?? 1)),
+    1
+  );
+  return Math.max(
+    Number(context.sheetRecord?.getCaseInsensitive(`SIZE${fontId}`) ?? 9),
+    1
+  );
+}
+function getTextPositioning(record) {
+  const justification = Math.min(
+    Math.max(Math.round(record.getNumber("JUSTIFICATION") ?? 0), 0),
+    8
+  );
+  const orientation = (Math.round(record.getNumber("ORIENTATION") ?? 0) % 4 + 4) % 4;
+  let column = justification % 3;
+  const row = Math.floor(justification / 3);
+  if (orientation === 2 || orientation === 3) column = 2 - column;
+  const horizontal = ["left", "center", "right"][column] ?? "left";
+  const vertical = ["bottom", "center", "top"][row] ?? "bottom";
+  const anchor = horizontal === "center" && vertical === "center" ? "center" : `${vertical}_${horizontal}`;
+  return {
+    anchor,
+    rotation: orientation === 1 || orientation === 3 ? 90 : 0
+  };
+}
+function shouldRenderSchematicRecord(record, context) {
+  let ownerPartId = record.getNumber("OWNERPARTID");
+  let ownerPartDisplayMode = record.getNumber("OWNERPARTDISPLAYMODE");
+  let current = record;
+  const visited = /* @__PURE__ */ new Set();
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const parent = context.document.getParent(current);
+    if (!parent) return true;
+    if (ownerPartId === void 0 || ownerPartId <= 0) {
+      ownerPartId = current.getNumber("OWNERPARTID");
+    }
+    if (ownerPartDisplayMode === void 0) {
+      ownerPartDisplayMode = current.getNumber("OWNERPARTDISPLAYMODE");
+    }
+    if (parent.recordKind === "1") {
+      const currentPartId = parent.getNumber("CURRENTPARTID") ?? 1;
+      return (ownerPartId === void 0 || ownerPartId <= 0 || ownerPartId === currentPartId) && (ownerPartDisplayMode === void 0 || ownerPartDisplayMode === 0);
+    }
+    current = parent;
+  }
+  return true;
+}
+function getLocation(record) {
+  if (record.getCaseInsensitive("LOCATION.X") === void 0 || record.getCaseInsensitive("LOCATION.Y") === void 0) {
+    return void 0;
+  }
+  return {
+    x: getCoordinate(record, "LOCATION.X"),
+    y: getCoordinate(record, "LOCATION.Y")
+  };
+}
+function getCorner(record) {
+  if (record.getCaseInsensitive("CORNER.X") === void 0 || record.getCaseInsensitive("CORNER.Y") === void 0) {
+    return void 0;
+  }
+  return {
+    x: getCoordinate(record, "CORNER.X"),
+    y: getCoordinate(record, "CORNER.Y")
+  };
+}
+function getRectangle(record) {
+  const location = getLocation(record);
+  const corner = getCorner(record);
+  if (!location || !corner) return void 0;
+  return {
+    minX: Math.min(location.x, corner.x),
+    minY: Math.min(location.y, corner.y),
+    maxX: Math.max(location.x, corner.x),
+    maxY: Math.max(location.y, corner.y)
+  };
+}
+function getCoordinate(record, key, fallback = 0) {
+  const integerPart = Number(record.getCaseInsensitive(key) ?? fallback);
+  const fractionRaw = record.getCaseInsensitive(`${key}_FRAC`);
+  if (!Number.isFinite(integerPart) || fractionRaw === void 0) {
+    return Number.isFinite(integerPart) ? integerPart : fallback;
+  }
+  const fraction = Number(`0.${fractionRaw.replace(/^[+-]/u, "")}`);
+  if (!Number.isFinite(fraction)) return integerPart;
+  return integerPart < 0 ? integerPart - fraction : integerPart + fraction;
+}
+function scalePoint(point, scale) {
+  return { x: point.x * scale, y: point.y * scale };
+}
+function approximateEllipse(center, radiusX, radiusY) {
+  return Array.from({ length: 49 }, (_, index) => {
+    const radians = index / 48 * Math.PI * 2;
+    return {
+      x: center.x + Math.cos(radians) * radiusX,
+      y: center.y + Math.sin(radians) * radiusY
+    };
+  });
+}
+function decodeMultilineText(text) {
+  return text.replaceAll("~1", "\n").replaceAll("\\n", "\n");
+}
+function altiumColorToCss(raw, fallback) {
+  if (raw === void 0) return fallback;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) return fallback;
+  const red = value & 255;
+  const green = value >>> 8 & 255;
+  const blue = value >>> 16 & 255;
+  return `#${toHex(red)}${toHex(green)}${toHex(blue)}`;
+}
+function toHex(value) {
+  return value.toString(16).padStart(2, "0");
+}
+
+// lib/convert-altium-to-circuit-json.ts
+import {
+  AltiumBinaryPcbDoc,
+  AltiumPcbDoc,
+  AltiumSchDoc,
+  parseAltiumFile,
+  parseAltiumPcbDoc,
+  parseAltiumSchDoc
+} from "altiumts";
+function convertAltiumToCircuitJson(source, options = {}) {
+  const sourceType = options.sourceType ?? "auto";
+  if (sourceType === "pcb") {
+    if (typeof source === "string") {
+      return convertAltiumPcbDocToCircuitJson(
+        parseAltiumPcbDoc(source),
+        options.pcb
+      );
+    }
+    const { document: document2 } = parseAltiumFile(toUint8Array(source));
+    if (!(document2 instanceof AltiumPcbDoc) && !(document2 instanceof AltiumBinaryPcbDoc)) {
+      throw new TypeError(
+        `Expected an Altium PCB document, got ${document2.type}`
+      );
+    }
+    return convertAltiumPcbDocToCircuitJson(document2, options.pcb);
+  }
+  if (sourceType === "schematic") {
+    return convertAltiumSchDocToCircuitJson(
+      parseAltiumSchDoc(normalizeSchematicSource(source)),
+      options.schematic
+    );
+  }
+  const bytes = toUint8Array(source);
+  const { document } = parseAltiumFile(bytes);
+  return convertAltiumDocumentToCircuitJson(document, options);
+}
+function convertAltiumDocumentToCircuitJson(document, options = {}) {
+  if (document instanceof AltiumSchDoc) {
+    return convertAltiumSchDocToCircuitJson(document, options.schematic);
+  }
+  if (document instanceof AltiumPcbDoc || document instanceof AltiumBinaryPcbDoc) {
+    return convertAltiumPcbDocToCircuitJson(document, options.pcb);
+  }
+  const type = typeof document === "object" && document !== null && "type" in document ? String(document.type) : typeof document;
+  throw new TypeError(`Unsupported Altium document type: ${type}`);
+}
+function toUint8Array(source) {
+  if (typeof source === "string") return new TextEncoder().encode(source);
+  if (source instanceof Uint8Array) return source;
+  return new Uint8Array(source);
+}
+function normalizeSchematicSource(source) {
+  return source instanceof ArrayBuffer ? new Uint8Array(source) : source;
+}
+export {
+  convertAltiumDocumentToCircuitJson,
+  convertAltiumPcbDocToCircuitJson,
+  convertAltiumSchDocToCircuitJson,
+  convertAltiumToCircuitJson
+};
+//# sourceMappingURL=index.js.map