circuit-json-to-step 0.0.1

package/dist/index.js

@@ -0,0 +1,705 @@
+// lib/index.ts
+import {
+  Repository,
+  ApplicationContext,
+  ApplicationProtocolDefinition,
+  ProductContext,
+  Product,
+  ProductDefinitionContext,
+  ProductDefinitionFormation,
+  ProductDefinition,
+  ProductDefinitionShape,
+  Unknown,
+  CartesianPoint as CartesianPoint2,
+  Direction as Direction2,
+  Axis2Placement3D as Axis2Placement3D2,
+  Plane as Plane2,
+  CylindricalSurface,
+  VertexPoint as VertexPoint2,
+  EdgeCurve as EdgeCurve2,
+  Line as Line2,
+  Vector as Vector2,
+  EdgeLoop as EdgeLoop2,
+  OrientedEdge as OrientedEdge2,
+  FaceOuterBound as FaceOuterBound2,
+  FaceBound,
+  AdvancedFace as AdvancedFace2,
+  Circle,
+  ClosedShell as ClosedShell2,
+  ManifoldSolidBrep as ManifoldSolidBrep2,
+  ColourRgb,
+  FillAreaStyleColour,
+  FillAreaStyle,
+  SurfaceStyleFillArea,
+  SurfaceSideStyle,
+  SurfaceStyleUsage,
+  PresentationStyleAssignment,
+  StyledItem,
+  MechanicalDesignGeometricPresentationRepresentation,
+  AdvancedBrepShapeRepresentation,
+  ShapeDefinitionRepresentation
+} from "stepts";
+
+// lib/mesh-generation.ts
+import { convertCircuitJsonTo3D } from "circuit-json-to-gltf";
+import {
+  AdvancedFace,
+  Axis2Placement3D,
+  CartesianPoint,
+  ClosedShell,
+  Direction,
+  EdgeCurve,
+  EdgeLoop,
+  FaceOuterBound,
+  Line,
+  ManifoldSolidBrep,
+  OrientedEdge,
+  Plane,
+  Vector,
+  VertexPoint
+} from "stepts";
+function createBoxTriangles(box) {
+  const { center, size } = box;
+  const halfX = size.x / 2;
+  const halfY = size.y / 2;
+  const halfZ = size.z / 2;
+  const corners = [
+    { x: -halfX, y: -halfY, z: -halfZ },
+    { x: halfX, y: -halfY, z: -halfZ },
+    { x: halfX, y: halfY, z: -halfZ },
+    { x: -halfX, y: halfY, z: -halfZ },
+    { x: -halfX, y: -halfY, z: halfZ },
+    { x: halfX, y: -halfY, z: halfZ },
+    { x: halfX, y: halfY, z: halfZ },
+    { x: -halfX, y: halfY, z: halfZ }
+  ].map((p) => ({ x: p.x + center.x, y: p.y + center.y, z: p.z + center.z }));
+  const triangles = [
+    // Bottom face (z = -halfZ)
+    {
+      vertices: [corners[0], corners[1], corners[2]],
+      normal: { x: 0, y: 0, z: -1 }
+    },
+    {
+      vertices: [corners[0], corners[2], corners[3]],
+      normal: { x: 0, y: 0, z: -1 }
+    },
+    // Top face (z = halfZ)
+    {
+      vertices: [corners[4], corners[6], corners[5]],
+      normal: { x: 0, y: 0, z: 1 }
+    },
+    {
+      vertices: [corners[4], corners[7], corners[6]],
+      normal: { x: 0, y: 0, z: 1 }
+    },
+    // Front face (y = -halfY)
+    {
+      vertices: [corners[0], corners[5], corners[1]],
+      normal: { x: 0, y: -1, z: 0 }
+    },
+    {
+      vertices: [corners[0], corners[4], corners[5]],
+      normal: { x: 0, y: -1, z: 0 }
+    },
+    // Back face (y = halfY)
+    {
+      vertices: [corners[2], corners[6], corners[7]],
+      normal: { x: 0, y: 1, z: 0 }
+    },
+    {
+      vertices: [corners[2], corners[7], corners[3]],
+      normal: { x: 0, y: 1, z: 0 }
+    },
+    // Left face (x = -halfX)
+    {
+      vertices: [corners[0], corners[3], corners[7]],
+      normal: { x: -1, y: 0, z: 0 }
+    },
+    {
+      vertices: [corners[0], corners[7], corners[4]],
+      normal: { x: -1, y: 0, z: 0 }
+    },
+    // Right face (x = halfX)
+    {
+      vertices: [corners[1], corners[6], corners[2]],
+      normal: { x: 1, y: 0, z: 0 }
+    },
+    {
+      vertices: [corners[1], corners[5], corners[6]],
+      normal: { x: 1, y: 0, z: 0 }
+    }
+  ];
+  return triangles;
+}
+function createStepFacesFromTriangles(repo, triangles) {
+  const faces = [];
+  for (const triangle of triangles) {
+    const v1 = repo.add(
+      new VertexPoint(
+        "",
+        repo.add(
+          new CartesianPoint(
+            "",
+            triangle.vertices[0].x,
+            triangle.vertices[0].y,
+            triangle.vertices[0].z
+          )
+        )
+      )
+    );
+    const v2 = repo.add(
+      new VertexPoint(
+        "",
+        repo.add(
+          new CartesianPoint(
+            "",
+            triangle.vertices[1].x,
+            triangle.vertices[1].y,
+            triangle.vertices[1].z
+          )
+        )
+      )
+    );
+    const v3 = repo.add(
+      new VertexPoint(
+        "",
+        repo.add(
+          new CartesianPoint(
+            "",
+            triangle.vertices[2].x,
+            triangle.vertices[2].y,
+            triangle.vertices[2].z
+          )
+        )
+      )
+    );
+    const p1 = v1.resolve(repo).pnt.resolve(repo);
+    const p2 = v2.resolve(repo).pnt.resolve(repo);
+    const createEdge = (vStart, vEnd) => {
+      const pStart = vStart.resolve(repo).pnt.resolve(repo);
+      const pEnd = vEnd.resolve(repo).pnt.resolve(repo);
+      const dir = repo.add(
+        new Direction(
+          "",
+          pEnd.x - pStart.x,
+          pEnd.y - pStart.y,
+          pEnd.z - pStart.z
+        )
+      );
+      const vec = repo.add(new Vector("", dir, 1));
+      const line = repo.add(new Line("", vStart.resolve(repo).pnt, vec));
+      return repo.add(new EdgeCurve("", vStart, vEnd, line, true));
+    };
+    const edge1 = createEdge(v1, v2);
+    const edge2 = createEdge(v2, v3);
+    const edge3 = createEdge(v3, v1);
+    const edgeLoop = repo.add(
+      new EdgeLoop("", [
+        repo.add(new OrientedEdge("", edge1, true)),
+        repo.add(new OrientedEdge("", edge2, true)),
+        repo.add(new OrientedEdge("", edge3, true))
+      ])
+    );
+    const normalDir = repo.add(
+      new Direction(
+        "",
+        triangle.normal.x,
+        triangle.normal.y,
+        triangle.normal.z
+      )
+    );
+    const refX = p2.x - p1.x;
+    const refY = p2.y - p1.y;
+    const refZ = p2.z - p1.z;
+    const refDir = repo.add(new Direction("", refX, refY, refZ));
+    const placement = repo.add(
+      new Axis2Placement3D("", v1.resolve(repo).pnt, normalDir, refDir)
+    );
+    const plane = repo.add(new Plane("", placement));
+    const face = repo.add(
+      new AdvancedFace(
+        "",
+        [repo.add(new FaceOuterBound("", edgeLoop, true))],
+        plane,
+        true
+      )
+    );
+    faces.push(face);
+  }
+  return faces;
+}
+async function generateComponentMeshes(options) {
+  const {
+    repo,
+    circuitJson,
+    boardThickness,
+    includeExternalMeshes = false
+  } = options;
+  const solids = [];
+  try {
+    const filteredCircuitJson = circuitJson.filter((e) => e.type !== "pcb_board").map((e) => {
+      if (!includeExternalMeshes && e.type === "cad_component") {
+        return {
+          ...e,
+          model_3mf_url: void 0,
+          model_obj_url: void 0,
+          model_stl_url: void 0,
+          model_glb_url: void 0,
+          model_gltf_url: void 0
+        };
+      }
+      return e;
+    });
+    const scene3d = await convertCircuitJsonTo3D(filteredCircuitJson, {
+      boardThickness,
+      renderBoardTextures: false
+    });
+    const allTriangles = [];
+    for (const box of scene3d.boxes) {
+      if (box.mesh && "triangles" in box.mesh) {
+        allTriangles.push(...box.mesh.triangles);
+      } else {
+        const boxTriangles = createBoxTriangles(box);
+        allTriangles.push(...boxTriangles);
+      }
+    }
+    if (allTriangles.length > 0) {
+      const transformedTriangles = allTriangles.map((tri) => ({
+        vertices: tri.vertices.map((v) => ({
+          x: v.x,
+          y: v.z,
+          // GLTF Z becomes STEP Y
+          z: v.y
+          // GLTF Y becomes STEP Z
+        })),
+        normal: {
+          x: tri.normal.x,
+          y: tri.normal.z,
+          // GLTF Z becomes STEP Y
+          z: tri.normal.y
+          // GLTF Y becomes STEP Z
+        }
+      }));
+      const componentFaces = createStepFacesFromTriangles(
+        repo,
+        transformedTriangles
+      );
+      const componentShell = repo.add(
+        new ClosedShell("", componentFaces)
+      );
+      const componentSolid = repo.add(
+        new ManifoldSolidBrep("Components", componentShell)
+      );
+      solids.push(componentSolid);
+    }
+  } catch (error) {
+    console.warn("Failed to generate component mesh:", error);
+  }
+  return solids;
+}
+
+// lib/index.ts
+async function circuitJsonToStep(circuitJson, options = {}) {
+  const repo = new Repository();
+  const pcbBoard = circuitJson.find((item) => item.type === "pcb_board");
+  const holes = circuitJson.filter(
+    (item) => item.type === "pcb_hole" || item.type === "pcb_plated_hole"
+  );
+  const boardWidth = options.boardWidth ?? pcbBoard?.width;
+  const boardHeight = options.boardHeight ?? pcbBoard?.height;
+  const boardThickness = options.boardThickness ?? pcbBoard?.thickness ?? 1.6;
+  const productName = options.productName ?? "PCB";
+  const boardCenterX = pcbBoard?.center?.x ?? 0;
+  const boardCenterY = pcbBoard?.center?.y ?? 0;
+  if (!boardWidth || !boardHeight) {
+    throw new Error(
+      "Board dimensions not found. Either provide boardWidth and boardHeight in options, or include a pcb_board in the circuit JSON with width and height properties."
+    );
+  }
+  const appContext = repo.add(
+    new ApplicationContext(
+      "core data for automotive mechanical design processes"
+    )
+  );
+  repo.add(
+    new ApplicationProtocolDefinition(
+      "international standard",
+      "automotive_design",
+      2010,
+      appContext
+    )
+  );
+  const productContext = repo.add(
+    new ProductContext("", appContext, "mechanical")
+  );
+  const product = repo.add(
+    new Product(productName, productName, "", [productContext])
+  );
+  const productDefContext = repo.add(
+    new ProductDefinitionContext("part definition", appContext, "design")
+  );
+  const productDefFormation = repo.add(
+    new ProductDefinitionFormation("", "", product)
+  );
+  const productDef = repo.add(
+    new ProductDefinition("", "", productDefFormation, productDefContext)
+  );
+  const productDefShape = repo.add(
+    new ProductDefinitionShape("", "", productDef)
+  );
+  const lengthUnit = repo.add(
+    new Unknown("", [
+      "( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) )"
+    ])
+  );
+  const angleUnit = repo.add(
+    new Unknown("", [
+      "( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) )"
+    ])
+  );
+  const solidAngleUnit = repo.add(
+    new Unknown("", [
+      "( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() )"
+    ])
+  );
+  const uncertainty = repo.add(
+    new Unknown("UNCERTAINTY_MEASURE_WITH_UNIT", [
+      `LENGTH_MEASURE(1.E-07)`,
+      `${lengthUnit}`,
+      `'distance_accuracy_value'`,
+      `'Maximum Tolerance'`
+    ])
+  );
+  const geomContext = repo.add(
+    new Unknown("", [
+      `( GEOMETRIC_REPRESENTATION_CONTEXT(3) GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((${uncertainty})) GLOBAL_UNIT_ASSIGNED_CONTEXT((${lengthUnit},${angleUnit},${solidAngleUnit})) REPRESENTATION_CONTEXT('${productName}','3D') )`
+    ])
+  );
+  const outline = pcbBoard?.outline;
+  let bottomVertices;
+  let topVertices;
+  if (outline && Array.isArray(outline) && outline.length >= 3) {
+    bottomVertices = outline.map(
+      (point) => repo.add(
+        new VertexPoint2(
+          "",
+          repo.add(new CartesianPoint2("", point.x, point.y, 0))
+        )
+      )
+    );
+    topVertices = outline.map(
+      (point) => repo.add(
+        new VertexPoint2(
+          "",
+          repo.add(new CartesianPoint2("", point.x, point.y, boardThickness))
+        )
+      )
+    );
+  } else {
+    const halfWidth = boardWidth / 2;
+    const halfHeight = boardHeight / 2;
+    const corners = [
+      [boardCenterX - halfWidth, boardCenterY - halfHeight, 0],
+      [boardCenterX + halfWidth, boardCenterY - halfHeight, 0],
+      [boardCenterX + halfWidth, boardCenterY + halfHeight, 0],
+      [boardCenterX - halfWidth, boardCenterY + halfHeight, 0],
+      [boardCenterX - halfWidth, boardCenterY - halfHeight, boardThickness],
+      [boardCenterX + halfWidth, boardCenterY - halfHeight, boardThickness],
+      [boardCenterX + halfWidth, boardCenterY + halfHeight, boardThickness],
+      [boardCenterX - halfWidth, boardCenterY + halfHeight, boardThickness]
+    ];
+    const vertices = corners.map(
+      ([x, y, z]) => repo.add(
+        new VertexPoint2("", repo.add(new CartesianPoint2("", x, y, z)))
+      )
+    );
+    bottomVertices = [vertices[0], vertices[1], vertices[2], vertices[3]];
+    topVertices = [vertices[4], vertices[5], vertices[6], vertices[7]];
+  }
+  function createEdge(v1, v2) {
+    const p1 = v1.resolve(repo).pnt.resolve(repo);
+    const p2 = v2.resolve(repo).pnt.resolve(repo);
+    const dir = repo.add(
+      new Direction2("", p2.x - p1.x, p2.y - p1.y, p2.z - p1.z)
+    );
+    const vec = repo.add(new Vector2("", dir, 1));
+    const line = repo.add(new Line2("", v1.resolve(repo).pnt, vec));
+    return repo.add(new EdgeCurve2("", v1, v2, line, true));
+  }
+  const bottomEdges = [];
+  const topEdges = [];
+  const verticalEdges = [];
+  for (let i = 0; i < bottomVertices.length; i++) {
+    const v1 = bottomVertices[i];
+    const v2 = bottomVertices[(i + 1) % bottomVertices.length];
+    bottomEdges.push(createEdge(v1, v2));
+  }
+  for (let i = 0; i < topVertices.length; i++) {
+    const v1 = topVertices[i];
+    const v2 = topVertices[(i + 1) % topVertices.length];
+    topEdges.push(createEdge(v1, v2));
+  }
+  for (let i = 0; i < bottomVertices.length; i++) {
+    verticalEdges.push(createEdge(bottomVertices[i], topVertices[i]));
+  }
+  const origin = repo.add(new CartesianPoint2("", 0, 0, 0));
+  const xDir = repo.add(new Direction2("", 1, 0, 0));
+  const zDir = repo.add(new Direction2("", 0, 0, 1));
+  const bottomFrame = repo.add(
+    new Axis2Placement3D2(
+      "",
+      origin,
+      repo.add(new Direction2("", 0, 0, -1)),
+      xDir
+    )
+  );
+  const bottomPlane = repo.add(new Plane2("", bottomFrame));
+  const bottomLoop = repo.add(
+    new EdgeLoop2(
+      "",
+      bottomEdges.map((edge) => repo.add(new OrientedEdge2("", edge, true)))
+    )
+  );
+  const bottomHoleLoops = [];
+  for (const hole of holes) {
+    const holeShape = hole.hole_shape || hole.shape;
+    if (holeShape === "circle") {
+      const holeX = typeof hole.x === "number" ? hole.x : hole.x.value;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y.value;
+      const radius = hole.hole_diameter / 2;
+      const holeCenter = repo.add(new CartesianPoint2("", holeX, holeY, 0));
+      const holeVertex = repo.add(
+        new VertexPoint2(
+          "",
+          repo.add(new CartesianPoint2("", holeX + radius, holeY, 0))
+        )
+      );
+      const holePlacement = repo.add(
+        new Axis2Placement3D2(
+          "",
+          holeCenter,
+          repo.add(new Direction2("", 0, 0, -1)),
+          xDir
+        )
+      );
+      const holeCircle = repo.add(new Circle("", holePlacement, radius));
+      const holeEdge = repo.add(
+        new EdgeCurve2("", holeVertex, holeVertex, holeCircle, true)
+      );
+      const holeLoop = repo.add(
+        new EdgeLoop2("", [repo.add(new OrientedEdge2("", holeEdge, false))])
+      );
+      bottomHoleLoops.push(repo.add(new FaceBound("", holeLoop, true)));
+    }
+  }
+  const bottomFace = repo.add(
+    new AdvancedFace2(
+      "",
+      [
+        repo.add(new FaceOuterBound2("", bottomLoop, true)),
+        ...bottomHoleLoops
+      ],
+      bottomPlane,
+      true
+    )
+  );
+  const topOrigin = repo.add(new CartesianPoint2("", 0, 0, boardThickness));
+  const topFrame = repo.add(new Axis2Placement3D2("", topOrigin, zDir, xDir));
+  const topPlane = repo.add(new Plane2("", topFrame));
+  const topLoop = repo.add(
+    new EdgeLoop2(
+      "",
+      topEdges.map((edge) => repo.add(new OrientedEdge2("", edge, false)))
+    )
+  );
+  const topHoleLoops = [];
+  for (const hole of holes) {
+    const holeShape = hole.hole_shape || hole.shape;
+    if (holeShape === "circle") {
+      const holeX = typeof hole.x === "number" ? hole.x : hole.x.value;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y.value;
+      const radius = hole.hole_diameter / 2;
+      const holeCenter = repo.add(
+        new CartesianPoint2("", holeX, holeY, boardThickness)
+      );
+      const holeVertex = repo.add(
+        new VertexPoint2(
+          "",
+          repo.add(
+            new CartesianPoint2("", holeX + radius, holeY, boardThickness)
+          )
+        )
+      );
+      const holePlacement = repo.add(
+        new Axis2Placement3D2("", holeCenter, zDir, xDir)
+      );
+      const holeCircle = repo.add(new Circle("", holePlacement, radius));
+      const holeEdge = repo.add(
+        new EdgeCurve2("", holeVertex, holeVertex, holeCircle, true)
+      );
+      const holeLoop = repo.add(
+        new EdgeLoop2("", [repo.add(new OrientedEdge2("", holeEdge, true))])
+      );
+      topHoleLoops.push(repo.add(new FaceBound("", holeLoop, true)));
+    }
+  }
+  const topFace = repo.add(
+    new AdvancedFace2(
+      "",
+      [repo.add(new FaceOuterBound2("", topLoop, true)), ...topHoleLoops],
+      topPlane,
+      true
+    )
+  );
+  const sideFaces = [];
+  for (let i = 0; i < bottomEdges.length; i++) {
+    const nextI = (i + 1) % bottomEdges.length;
+    const bottomV1Pnt = bottomVertices[i].resolve(repo).pnt;
+    const bottomV2Pnt = bottomVertices[nextI].resolve(repo).pnt;
+    const bottomV1 = bottomV1Pnt.resolve(repo);
+    const bottomV2 = bottomV2Pnt.resolve(repo);
+    const edgeDir = {
+      x: bottomV2.x - bottomV1.x,
+      y: bottomV2.y - bottomV1.y,
+      z: 0
+    };
+    const normalDir = repo.add(new Direction2("", edgeDir.y, -edgeDir.x, 0));
+    const refDir = repo.add(new Direction2("", edgeDir.x, edgeDir.y, 0));
+    const sideFrame = repo.add(
+      new Axis2Placement3D2("", bottomV1Pnt, normalDir, refDir)
+    );
+    const sidePlane = repo.add(new Plane2("", sideFrame));
+    const sideLoop = repo.add(
+      new EdgeLoop2("", [
+        repo.add(new OrientedEdge2("", bottomEdges[i], true)),
+        repo.add(new OrientedEdge2("", verticalEdges[nextI], true)),
+        repo.add(new OrientedEdge2("", topEdges[i], false)),
+        repo.add(new OrientedEdge2("", verticalEdges[i], false))
+      ])
+    );
+    const sideFace = repo.add(
+      new AdvancedFace2(
+        "",
+        [repo.add(new FaceOuterBound2("", sideLoop, true))],
+        sidePlane,
+        true
+      )
+    );
+    sideFaces.push(sideFace);
+  }
+  const holeCylindricalFaces = [];
+  for (const hole of holes) {
+    const holeShape = hole.hole_shape || hole.shape;
+    if (holeShape === "circle") {
+      const holeX = typeof hole.x === "number" ? hole.x : hole.x.value;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y.value;
+      const radius = hole.hole_diameter / 2;
+      const bottomHoleCenter = repo.add(new CartesianPoint2("", holeX, holeY, 0));
+      const bottomHoleVertex = repo.add(
+        new VertexPoint2(
+          "",
+          repo.add(new CartesianPoint2("", holeX + radius, holeY, 0))
+        )
+      );
+      const bottomHolePlacement = repo.add(
+        new Axis2Placement3D2(
+          "",
+          bottomHoleCenter,
+          repo.add(new Direction2("", 0, 0, -1)),
+          xDir
+        )
+      );
+      const bottomHoleCircle = repo.add(
+        new Circle("", bottomHolePlacement, radius)
+      );
+      const bottomHoleEdge = repo.add(
+        new EdgeCurve2(
+          "",
+          bottomHoleVertex,
+          bottomHoleVertex,
+          bottomHoleCircle,
+          true
+        )
+      );
+      const topHoleCenter = repo.add(
+        new CartesianPoint2("", holeX, holeY, boardThickness)
+      );
+      const topHoleVertex = repo.add(
+        new VertexPoint2(
+          "",
+          repo.add(
+            new CartesianPoint2("", holeX + radius, holeY, boardThickness)
+          )
+        )
+      );
+      const topHolePlacement = repo.add(
+        new Axis2Placement3D2("", topHoleCenter, zDir, xDir)
+      );
+      const topHoleCircle = repo.add(new Circle("", topHolePlacement, radius));
+      const topHoleEdge = repo.add(
+        new EdgeCurve2("", topHoleVertex, topHoleVertex, topHoleCircle, true)
+      );
+      const holeCylinderLoop = repo.add(
+        new EdgeLoop2("", [
+          repo.add(new OrientedEdge2("", bottomHoleEdge, true)),
+          repo.add(new OrientedEdge2("", topHoleEdge, false))
+        ])
+      );
+      const holeCylinderPlacement = repo.add(
+        new Axis2Placement3D2("", bottomHoleCenter, zDir, xDir)
+      );
+      const holeCylinderSurface = repo.add(
+        new CylindricalSurface("", holeCylinderPlacement, radius)
+      );
+      const holeCylinderFace = repo.add(
+        new AdvancedFace2(
+          "",
+          [repo.add(new FaceOuterBound2("", holeCylinderLoop, true))],
+          holeCylinderSurface,
+          false
+        )
+      );
+      holeCylindricalFaces.push(holeCylinderFace);
+    }
+  }
+  const allFaces = [bottomFace, topFace, ...sideFaces, ...holeCylindricalFaces];
+  const shell = repo.add(new ClosedShell2("", allFaces));
+  const solid = repo.add(new ManifoldSolidBrep2(productName, shell));
+  const allSolids = [solid];
+  if (options.includeComponents) {
+    const componentSolids = await generateComponentMeshes({
+      repo,
+      circuitJson,
+      boardThickness,
+      includeExternalMeshes: options.includeExternalMeshes
+    });
+    allSolids.push(...componentSolids);
+  }
+  const styledItems = [];
+  for (const solidRef of allSolids) {
+    const color = repo.add(new ColourRgb("", 0.2, 0.6, 0.2));
+    const fillColor = repo.add(new FillAreaStyleColour("", color));
+    const fillStyle = repo.add(new FillAreaStyle("", [fillColor]));
+    const surfaceFill = repo.add(new SurfaceStyleFillArea(fillStyle));
+    const surfaceSide = repo.add(new SurfaceSideStyle("", [surfaceFill]));
+    const surfaceUsage = repo.add(new SurfaceStyleUsage(".BOTH.", surfaceSide));
+    const presStyle = repo.add(new PresentationStyleAssignment([surfaceUsage]));
+    const styledItem = repo.add(new StyledItem("", [presStyle], solidRef));
+    styledItems.push(styledItem);
+  }
+  repo.add(
+    new MechanicalDesignGeometricPresentationRepresentation(
+      "",
+      styledItems,
+      geomContext
+    )
+  );
+  const shapeRep = repo.add(
+    new AdvancedBrepShapeRepresentation(productName, allSolids, geomContext)
+  );
+  repo.add(new ShapeDefinitionRepresentation(productDefShape, shapeRep));
+  return repo.toPartFile({ name: productName });
+}
+export {
+  circuitJsonToStep
+};