calculate-packing 0.0.7 → 0.0.9

package/dist/index.d.ts

@@ -142,7 +142,9 @@ declare class PackSolver extends BaseSolver {
     getResult(): PackedComponent[];
 }
 
-declare const convertCircuitJsonToPackOutput: (circuitJson: CircuitJson) => PackOutput;
+declare const convertCircuitJsonToPackOutput: (circuitJson: CircuitJson, opts?: {
+    source_group_id?: string;
+}) => PackOutput;
 
 declare const getGraphicsFromPackOutput: (packOutput: PackOutput) => GraphicsObject;
 

package/dist/index.js

@@ -719,17 +719,187 @@ var pack = (input) => {
   };
 };
 
-// lib/testing/convertCircuitJsonToPackOutput.ts
-import { cju } from "@tscircuit/circuit-json-util";
-var convertCircuitJsonToPackOutput = (circuitJson) => {
+// lib/plumbing/convertCircuitJsonToPackOutput.ts
+import { cju, getCircuitJsonTree } from "@tscircuit/circuit-json-util";
+
+// lib/plumbing/extractPadInfos.ts
+var extractPadInfos = (pcbComponent, db, getNetworkId) => {
+  const out = [];
+  const pushPad = ({
+    padId,
+    pcbPortId,
+    sx,
+    sy,
+    x,
+    y
+  }) => out.push({
+    padId,
+    networkId: getNetworkId(pcbPortId),
+    size: { x: sx, y: sy },
+    absoluteCenter: { x, y }
+  });
+  for (const ph of db.pcb_plated_hole.list({
+    pcb_component_id: pcbComponent.pcb_component_id
+  })) {
+    switch (ph.shape) {
+      case "circle": {
+        pushPad({
+          padId: ph.pcb_plated_hole_id,
+          pcbPortId: ph.pcb_port_id,
+          sx: ph.outer_diameter ?? ph.hole_diameter ?? 0,
+          sy: ph.outer_diameter ?? ph.hole_diameter ?? 0,
+          x: ph.x,
+          y: ph.y
+        });
+        break;
+      }
+      case "oval": {
+        pushPad({
+          padId: ph.pcb_plated_hole_id,
+          pcbPortId: ph.pcb_port_id,
+          sx: ph.outer_width,
+          sy: ph.outer_height,
+          x: ph.x,
+          y: ph.y
+        });
+        break;
+      }
+      case "circular_hole_with_rect_pad": {
+        pushPad({
+          padId: ph.pcb_plated_hole_id,
+          pcbPortId: ph.pcb_port_id,
+          sx: ph.rect_pad_width,
+          sy: ph.rect_pad_height,
+          x: ph.x,
+          y: ph.y
+        });
+        break;
+      }
+      case "pill": {
+        pushPad({
+          padId: ph.pcb_plated_hole_id,
+          pcbPortId: ph.pcb_port_id,
+          sx: ph.outer_width,
+          sy: ph.outer_height,
+          x: ph.x,
+          y: ph.y
+        });
+        break;
+      }
+      case "pill_hole_with_rect_pad": {
+        pushPad({
+          padId: ph.pcb_plated_hole_id,
+          pcbPortId: ph.pcb_port_id,
+          sx: ph.rect_pad_width,
+          sy: ph.rect_pad_height,
+          x: ph.x,
+          y: ph.y
+        });
+        break;
+      }
+    }
+    console.warn(`Unsupported plated hole shape ${ph.shape}`);
+  }
+  for (const sp of db.pcb_smtpad.list({
+    pcb_component_id: pcbComponent.pcb_component_id
+  })) {
+    switch (sp.shape) {
+      case "rect": {
+        pushPad({
+          padId: sp.pcb_smtpad_id,
+          pcbPortId: sp.pcb_port_id,
+          sx: sp.width ?? 0,
+          sy: sp.height ?? 0,
+          x: sp.x,
+          y: sp.y
+        });
+        break;
+      }
+      case "circle": {
+        pushPad({
+          padId: sp.pcb_smtpad_id,
+          pcbPortId: sp.pcb_port_id,
+          sx: sp.radius ?? 0,
+          sy: sp.radius ?? 0,
+          x: sp.x,
+          y: sp.y
+        });
+        break;
+      }
+      case "pill": {
+        pushPad({
+          padId: sp.pcb_smtpad_id,
+          pcbPortId: sp.pcb_port_id,
+          sx: sp.width ?? 0,
+          sy: sp.height ?? 0,
+          x: sp.x,
+          y: sp.y
+        });
+        break;
+      }
+      default: {
+        console.warn(
+          `smtpad shape ${sp.shape} pads are not supported in pack layout yet`
+        );
+        break;
+      }
+    }
+  }
+  return out;
+};
+
+// lib/plumbing/convertCircuitJsonToPackOutput.ts
+var buildPackedComponent = (pcbComponents, componentId, db, getNetworkId) => {
+  const padInfos = pcbComponents.flatMap(
+    (pc) => extractPadInfos(pc, db, getNetworkId)
+  );
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of padInfos) {
+    minX = Math.min(minX, p.absoluteCenter.x - p.size.x / 2);
+    maxX = Math.max(maxX, p.absoluteCenter.x + p.size.x / 2);
+    minY = Math.min(minY, p.absoluteCenter.y - p.size.y / 2);
+    maxY = Math.max(maxY, p.absoluteCenter.y + p.size.y / 2);
+  }
+  const center = { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+  const pads = padInfos.map((p) => ({
+    padId: p.padId,
+    networkId: p.networkId,
+    type: "rect",
+    size: p.size,
+    absoluteCenter: p.absoluteCenter,
+    offset: {
+      x: p.absoluteCenter.x - center.x,
+      y: p.absoluteCenter.y - center.y
+    }
+  }));
+  return {
+    componentId,
+    center,
+    ccwRotationOffset: 0,
+    pads
+  };
+};
+var collectPcbComponents = (node, db) => {
+  if (node.nodeType === "component") {
+    const pcbId = node.otherChildElements[0]?.pcb_component_id;
+    return pcbId ? [db.pcb_component.get(pcbId)] : [];
+  }
+  return node.childNodes.flatMap((n) => collectPcbComponents(n, db));
+};
+var convertCircuitJsonToPackOutput = (circuitJson, opts = {}) => {
   const packOutput = {
     components: [],
     minGap: 0,
     packOrderStrategy: "largest_to_smallest",
     packPlacementStrategy: "shortest_connection_along_outline"
   };
+  const tree = getCircuitJsonTree(circuitJson, {
+    source_group_id: opts.source_group_id
+  });
   const db = cju(circuitJson);
-  const pcbComponents = db.pcb_component.list();
   let unnamedCounter = 0;
   const getNetworkId = (pcbPortId) => {
     if (pcbPortId) {
@@ -743,68 +913,29 @@ var convertCircuitJsonToPackOutput = (circuitJson) => {
     }
     return `unnamed${unnamedCounter++}`;
   };
-  for (const pcbComponent of pcbComponents) {
-    const pads = [];
-    const platedHoles = db.pcb_plated_hole.list({
-      pcb_component_id: pcbComponent.pcb_component_id
-    });
-    for (const platedHole of platedHoles) {
-      const sx = platedHole.rect_pad_width ?? platedHole.outer_diameter ?? platedHole.hole_diameter ?? 0;
-      const sy = platedHole.rect_pad_height ?? platedHole.outer_diameter ?? platedHole.hole_diameter ?? 0;
-      const networkId = getNetworkId(platedHole.pcb_port_id);
-      const pad = {
-        padId: platedHole.pcb_plated_hole_id,
-        networkId,
-        type: "rect",
-        offset: {
-          x: platedHole.x - pcbComponent.center.x,
-          y: platedHole.y - pcbComponent.center.y
-        },
-        size: { x: sx, y: sy },
-        absoluteCenter: {
-          x: platedHole.x,
-          y: platedHole.y
-        }
-      };
-      pads.push(pad);
-    }
-    const smtPads = db.pcb_smtpad.list({
-      pcb_component_id: pcbComponent.pcb_component_id
-    });
-    for (const smtPad of smtPads) {
-      if (smtPad.shape === "polygon") {
-        throw new Error("Polygon pads are not supported in pack layout yet");
-      }
-      const networkId = getNetworkId(smtPad.pcb_port_id);
-      const pad = {
-        padId: smtPad.pcb_smtpad_id,
-        networkId,
-        type: "rect",
-        offset: {
-          x: smtPad.x - pcbComponent.center.x,
-          y: smtPad.y - pcbComponent.center.y
-        },
-        size: {
-          x: smtPad.width ?? 0,
-          y: smtPad.height ?? 0
-        },
-        absoluteCenter: {
-          x: smtPad.x,
-          y: smtPad.y
-        }
-      };
-      pads.push(pad);
+  const topLevelNodes = tree.childNodes ?? [];
+  for (const node of topLevelNodes) {
+    if (node.nodeType === "component") {
+      const pcbComponent = node.otherChildElements.find(
+        (e) => e.type === "pcb_component"
+      );
+      if (!pcbComponent) continue;
+      packOutput.components.push(
+        buildPackedComponent(
+          [pcbComponent],
+          pcbComponent.pcb_component_id,
+          db,
+          getNetworkId
+        )
+      );
+    } else if (node.nodeType === "group") {
+      const pcbComps = collectPcbComponents(node, db);
+      if (!pcbComps.length) continue;
+      const compId = node.sourceGroup?.source_group_id ?? node.sourceGroup?.name ?? `group_${packOutput.components.length}`;
+      packOutput.components.push(
+        buildPackedComponent(pcbComps, compId, db, getNetworkId)
+      );
     }
-    const packedComponent = {
-      componentId: pcbComponent.pcb_component_id,
-      pads,
-      center: {
-        x: pcbComponent.center.x,
-        y: pcbComponent.center.y
-      },
-      ccwRotationOffset: 0
-    };
-    packOutput.components.push(packedComponent);
   }
   return packOutput;
 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "calculate-packing",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",
@@ -18,7 +18,7 @@
     "@biomejs/biome": "^2.1.1",
     "@flatten-js/core": "^1.6.2",
     "@react-hook/resize-observer": "^2.0.2",
-    "@tscircuit/circuit-json-util": "^0.0.52",
+    "@tscircuit/circuit-json-util": "^0.0.57",
     "@tscircuit/footprinter": "^0.0.203",
     "@tscircuit/math-utils": "^0.0.19",
     "@types/bun": "latest",
@@ -31,6 +31,7 @@
     "react-cosmos": "^7.0.0",
     "react-cosmos-plugin-vite": "^7.0.0",
     "react-dom": "^19.1.0",
+    "tscircuit": "^0.0.562",
     "tsup": "^8.5.0",
     "vite": "^7.0.5"
   },