calculate-packing 0.0.71 → 0.0.73

package/dist/index.d.ts

@@ -29,6 +29,14 @@ interface OutputPad extends InputPad {
         y: number;
     };
 }
+interface ComponentCourtyard {
+    offsetFromCenter: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+}
 interface InputComponent {
     componentId: string;
     /** Components marked as static are not moved by the packer */
@@ -45,6 +53,8 @@ interface InputComponent {
     /** Preconfigured rotation (degrees CCW) for static components */
     ccwRotationOffset?: number;
     pads: InputPad[];
+    /** Optional courtyard defining the component's physical boundary */
+    courtyard?: ComponentCourtyard;
 }
 interface PackedComponent extends InputComponent {
     center: {
@@ -588,4 +598,4 @@ declare class PackSolver2 extends BaseSolver$1 {
     };
 }
 
-export { type ComponentId, type GlobalBounds, type InputComponent, type InputObstacle, type InputPad, LargestRectOutsideOutlineFromPointSolver, type NetworkId, type OutputPad, type PackInput, type PackOutput, type PackPlacementStrategy, PackSolver2, type PackedComponent, type PadId, type Point$1 as Point, type Rect, convertCircuitJsonToPackOutput, convertPackOutputToPackInput, getGraphicsFromPackOutput, pack };
+export { type ComponentCourtyard, type ComponentId, type GlobalBounds, type InputComponent, type InputObstacle, type InputPad, LargestRectOutsideOutlineFromPointSolver, type NetworkId, type OutputPad, type PackInput, type PackOutput, type PackPlacementStrategy, PackSolver2, type PackedComponent, type PadId, type Point$1 as Point, type Rect, convertCircuitJsonToPackOutput, convertPackOutputToPackInput, getGraphicsFromPackOutput, pack };

package/dist/index.js

@@ -68,6 +68,30 @@ var combineBounds = (bounds) => {
   return { minX, minY, maxX, maxY };
 };
 
+// lib/geometry/expandRotatedRectIntoBounds.ts
+function expandRotatedRectIntoBounds(opts) {
+  const { bounds, center, width, height, angleRad } = opts;
+  const tx = opts.translate?.x ?? 0;
+  const ty = opts.translate?.y ?? 0;
+  const hw = width / 2;
+  const hh = height / 2;
+  const corners = [
+    { x: center.x - hw, y: center.y - hh },
+    { x: center.x + hw, y: center.y - hh },
+    { x: center.x + hw, y: center.y + hh },
+    { x: center.x - hw, y: center.y + hh }
+  ];
+  for (const corner of corners) {
+    const rotated = rotatePoint(corner, angleRad);
+    const x = rotated.x + tx;
+    const y = rotated.y + ty;
+    bounds.minX = Math.min(bounds.minX, x);
+    bounds.maxX = Math.max(bounds.maxX, x);
+    bounds.minY = Math.min(bounds.minY, y);
+    bounds.maxY = Math.max(bounds.maxY, y);
+  }
+}
+
 // lib/geometry/getComponentBounds.ts
 var getComponentBounds = (component, minGap = 0) => {
   const bounds = {
@@ -76,28 +100,27 @@ var getComponentBounds = (component, minGap = 0) => {
     minY: Infinity,
     maxY: -Infinity
   };
-  component.pads.forEach((pad) => {
-    const hw = pad.size.x / 2;
-    const hh = pad.size.y / 2;
-    const localCorners = [
-      { x: pad.offset.x - hw, y: pad.offset.y - hh },
-      { x: pad.offset.x + hw, y: pad.offset.y - hh },
-      { x: pad.offset.x + hw, y: pad.offset.y + hh },
-      { x: pad.offset.x - hw, y: pad.offset.y + hh }
-    ];
-    localCorners.forEach((corner) => {
-      const world = rotatePoint(
-        corner,
-        component.ccwRotationOffset * Math.PI / 180
-      );
-      const x = world.x + component.center.x;
-      const y = world.y + component.center.y;
-      bounds.minX = Math.min(bounds.minX, x);
-      bounds.maxX = Math.max(bounds.maxX, x);
-      bounds.minY = Math.min(bounds.minY, y);
-      bounds.maxY = Math.max(bounds.maxY, y);
+  const angleRad = component.ccwRotationOffset * Math.PI / 180;
+  for (const pad of component.pads) {
+    expandRotatedRectIntoBounds({
+      bounds,
+      center: pad.offset,
+      width: pad.size.x,
+      height: pad.size.y,
+      angleRad,
+      translate: component.center
     });
-  });
+  }
+  if (component.courtyard) {
+    expandRotatedRectIntoBounds({
+      bounds,
+      center: component.courtyard.offsetFromCenter,
+      width: component.courtyard.width,
+      height: component.courtyard.height,
+      angleRad,
+      translate: component.center
+    });
+  }
   return {
     minX: bounds.minX - minGap,
     maxX: bounds.maxX + minGap,
@@ -251,6 +274,50 @@ function parseFlattenPolygonSegments(polygon) {
 }
 
 // lib/constructOutlinesFromPackedComponents.ts
+var createCourtyardPolygon = (opts) => {
+  const { component, courtyard, minGap } = opts;
+  const hw = courtyard.width / 2 + minGap;
+  const hh = courtyard.height / 2 + minGap;
+  const localCorners = [
+    {
+      x: courtyard.offsetFromCenter.x - hw,
+      y: courtyard.offsetFromCenter.y - hh
+    },
+    {
+      x: courtyard.offsetFromCenter.x + hw,
+      y: courtyard.offsetFromCenter.y - hh
+    },
+    {
+      x: courtyard.offsetFromCenter.x + hw,
+      y: courtyard.offsetFromCenter.y + hh
+    },
+    {
+      x: courtyard.offsetFromCenter.x - hw,
+      y: courtyard.offsetFromCenter.y + hh
+    }
+  ];
+  const worldCorners = localCorners.map((corner) => {
+    const rotated = rotatePoint(
+      corner,
+      component.ccwRotationOffset * Math.PI / 180
+    );
+    return {
+      x: rotated.x + component.center.x,
+      y: rotated.y + component.center.y
+    };
+  });
+  const arr = worldCorners.map(({ x, y }) => [x, y]);
+  const poly = new Flatten.Polygon(arr);
+  const xs = worldCorners.map((p) => p.x);
+  const ys = worldCorners.map((p) => p.y);
+  const bbox = {
+    minX: Math.min(...xs),
+    minY: Math.min(...ys),
+    maxX: Math.max(...xs),
+    maxY: Math.max(...ys)
+  };
+  return { poly, bbox };
+};
 var createPadPolygons = (component, minGap) => {
   return component.pads.map((pad) => {
     const hw = pad.size.x / 2 + minGap;
@@ -322,8 +389,18 @@ var constructOutlinesFromPackedComponents = (components, opts = {}) => {
   const bounds = combineBounds([...componentBounds, ...obstacleBounds]);
   const allPadShapes = [];
   for (const component of components) {
-    const padShapes = createPadPolygons(component, minGap);
-    allPadShapes.push(...padShapes);
+    if (component.courtyard) {
+      allPadShapes.push(
+        createCourtyardPolygon({
+          component,
+          courtyard: component.courtyard,
+          minGap
+        })
+      );
+    } else {
+      const padShapes = createPadPolygons(component, minGap);
+      allPadShapes.push(...padShapes);
+    }
   }
   const obstacleShapes = createObstaclePolygons(obstacles, minGap);
   allPadShapes.push(...obstacleShapes);
@@ -1363,31 +1440,26 @@ var getInputComponentBounds = (component, { rotationDegrees = 0 }) => {
     minY: Infinity,
     maxY: -Infinity
   };
+  const angleRad = rotationDegrees * Math.PI / 180;
   for (const pad of component.pads) {
-    const hw = pad.size.x / 2;
-    const hh = pad.size.y / 2;
-    const localCorners = [
-      { x: pad.offset.x - hw, y: pad.offset.y - hh },
-      { x: pad.offset.x + hw, y: pad.offset.y - hh },
-      { x: pad.offset.x + hw, y: pad.offset.y + hh },
-      { x: pad.offset.x - hw, y: pad.offset.y + hh }
-    ];
-    for (const corner of localCorners) {
-      const world = rotatePoint(corner, rotationDegrees * Math.PI / 180);
-      const x = world.x;
-      const y = world.y;
-      bounds.minX = Math.min(bounds.minX, x);
-      bounds.maxX = Math.max(bounds.maxX, x);
-      bounds.minY = Math.min(bounds.minY, y);
-      bounds.maxY = Math.max(bounds.maxY, y);
-    }
+    expandRotatedRectIntoBounds({
+      bounds,
+      center: pad.offset,
+      width: pad.size.x,
+      height: pad.size.y,
+      angleRad
+    });
   }
-  return {
-    minX: bounds.minX,
-    maxX: bounds.maxX,
-    minY: bounds.minY,
-    maxY: bounds.maxY
-  };
+  if (component.courtyard) {
+    expandRotatedRectIntoBounds({
+      bounds,
+      center: component.courtyard.offsetFromCenter,
+      width: component.courtyard.width,
+      height: component.courtyard.height,
+      angleRad
+    });
+  }
+  return bounds;
 };
 
 // lib/math/expandSegment.ts
@@ -1757,7 +1829,8 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
             y: center.y + rotatedOffset.y
           }
         };
-      })
+      }),
+      courtyard: this.componentToPack.courtyard
     };
   }
   /**
@@ -2114,28 +2187,54 @@ var getGraphicsFromPackOutput = (packOutput) => {
 
 // lib/PackSolver2/checkOverlapWithPackedComponents.ts
 import { computeDistanceBetweenBoxes } from "@tscircuit/math-utils";
+
+// lib/PackSolver2/getComponentCollisionBoxes.ts
+function getComponentCollisionBoxes(component) {
+  if (component.courtyard) {
+    const courtyard = component.courtyard;
+    const angleRad = component.ccwRotationOffset * Math.PI / 180;
+    const rotatedOffset = rotatePoint(courtyard.offsetFromCenter, angleRad);
+    const normalizedDeg = (component.ccwRotationOffset % 360 + 360) % 360;
+    const swapDims = normalizedDeg === 90 || normalizedDeg === 270;
+    let width = courtyard.width;
+    let height = courtyard.height;
+    if (swapDims) {
+      width = courtyard.height;
+      height = courtyard.width;
+    }
+    return [
+      {
+        center: {
+          x: component.center.x + rotatedOffset.x,
+          y: component.center.y + rotatedOffset.y
+        },
+        width,
+        height
+      }
+    ];
+  }
+  return component.pads.map((p) => ({
+    center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
+    width: p.size.x,
+    height: p.size.y
+  }));
+}
+
+// lib/PackSolver2/checkOverlapWithPackedComponents.ts
 function checkOverlapWithPackedComponents({
   component,
   packedComponents,
   minGap
 }) {
-  const allPackedPadBoxes = packedComponents.flatMap(
-    (c) => c.pads.map((p) => ({
-      center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
-      width: p.size.x,
-      height: p.size.y
-    }))
+  const allPackedBoxes = packedComponents.flatMap(
+    (c) => getComponentCollisionBoxes(c)
   );
-  const newComponentPadBoxes = component.pads.map((p) => ({
-    center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
-    width: p.size.x,
-    height: p.size.y
-  }));
-  for (const newComponentPadBox of newComponentPadBoxes) {
-    for (const packedPadBox of allPackedPadBoxes) {
+  const newComponentBoxes = getComponentCollisionBoxes(component);
+  for (const newBox of newComponentBoxes) {
+    for (const packedBox of allPackedBoxes) {
       const { distance: boxDist } = computeDistanceBetweenBoxes(
-        newComponentPadBox,
-        packedPadBox
+        newBox,
+        packedBox
       );
       if (boxDist + 1e-6 < minGap) {
         return {
@@ -2216,19 +2315,15 @@ var SingleComponentPackSolver = class extends BaseSolver4 {
       const position = { x: 0, y: 0 };
       const rotation = availableRotations2[0] ?? 0;
       const candidate = this.createPackedComponent(position, rotation);
+      const candidateBoxes = getComponentCollisionBoxes(candidate);
       const tooCloseToObstacles = (this.obstacles ?? []).some((obs) => {
         const obsBox = {
           center: { x: obs.absoluteCenter.x, y: obs.absoluteCenter.y },
           width: obs.width,
           height: obs.height
         };
-        return candidate.pads.some((p) => {
-          const padBox = {
-            center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
-            width: p.size.x,
-            height: p.size.y
-          };
-          const { distance } = computeDistanceBetweenBoxes2(padBox, obsBox);
+        return candidateBoxes.some((box) => {
+          const { distance } = computeDistanceBetweenBoxes2(box, obsBox);
           return distance + 1e-6 < this.minGap;
         });
       });
@@ -2333,19 +2428,15 @@ var SingleComponentPackSolver = class extends BaseSolver4 {
           minGap: this.minGap
         });
         let minObstacleGapDistance = Infinity;
+        const candidateCollisionBoxes = getComponentCollisionBoxes(candidateComponent);
         const tooCloseToObstacles = (this.obstacles ?? []).some((obs) => {
           const obsBox = {
             center: { x: obs.absoluteCenter.x, y: obs.absoluteCenter.y },
             width: obs.width,
             height: obs.height
           };
-          return candidateComponent.pads.some((p) => {
-            const padBox = {
-              center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
-              width: p.size.x,
-              height: p.size.y
-            };
-            const { distance: distance2 } = computeDistanceBetweenBoxes2(padBox, obsBox);
+          return candidateCollisionBoxes.some((box) => {
+            const { distance: distance2 } = computeDistanceBetweenBoxes2(box, obsBox);
             minObstacleGapDistance = Math.min(minObstacleGapDistance, distance2);
             return distance2 + 1e-6 < this.minGap;
           });
@@ -2795,19 +2886,15 @@ var PackSolver2 = class extends BaseSolver5 {
     };
     setPackedComponentPadCenters(newPackedComponent);
     const obstacles = this.packInput.obstacles ?? [];
+    const newComponentBoxes = getComponentCollisionBoxes(newPackedComponent);
     const tooCloseToObstacles = obstacles.some((obs) => {
       const obsBox = {
         center: { x: obs.absoluteCenter.x, y: obs.absoluteCenter.y },
         width: obs.width,
         height: obs.height
       };
-      return newPackedComponent.pads.some((p) => {
-        const padBox = {
-          center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
-          width: p.size.x,
-          height: p.size.y
-        };
-        const { distance } = computeDistanceBetweenBoxes3(padBox, obsBox);
+      return newComponentBoxes.some((box) => {
+        const { distance } = computeDistanceBetweenBoxes3(box, obsBox);
         return distance + 1e-6 < this.packInput.minGap;
       });
     });
@@ -3234,6 +3321,64 @@ var getObstacleFromElement = (element) => {
 };
 
 // lib/plumbing/convertCircuitJsonToPackOutput.ts
+var extractCourtyardForComponent = (opts) => {
+  const { db, pcbComponentIds, componentCenter } = opts;
+  const uniquePcbComponentIds = Array.from(new Set(pcbComponentIds));
+  if (uniquePcbComponentIds.length !== 1) return void 0;
+  const idSet = new Set(pcbComponentIds);
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let found = false;
+  for (const rect of db.pcb_courtyard_rect.list()) {
+    if (!idSet.has(rect.pcb_component_id)) continue;
+    minX = Math.min(minX, rect.center.x - rect.width / 2);
+    maxX = Math.max(maxX, rect.center.x + rect.width / 2);
+    minY = Math.min(minY, rect.center.y - rect.height / 2);
+    maxY = Math.max(maxY, rect.center.y + rect.height / 2);
+    found = true;
+  }
+  for (const polygon of db.pcb_courtyard_polygon.list()) {
+    if (!idSet.has(polygon.pcb_component_id)) continue;
+    for (const pt of polygon.points) {
+      minX = Math.min(minX, pt.x);
+      maxX = Math.max(maxX, pt.x);
+      minY = Math.min(minY, pt.y);
+      maxY = Math.max(maxY, pt.y);
+    }
+    found = true;
+  }
+  for (const outline of db.pcb_courtyard_outline.list()) {
+    if (!idSet.has(outline.pcb_component_id)) continue;
+    for (const pt of outline.outline) {
+      minX = Math.min(minX, pt.x);
+      maxX = Math.max(maxX, pt.x);
+      minY = Math.min(minY, pt.y);
+      maxY = Math.max(maxY, pt.y);
+    }
+    found = true;
+  }
+  for (const circle of db.pcb_courtyard_circle.list()) {
+    if (!idSet.has(circle.pcb_component_id)) continue;
+    minX = Math.min(minX, circle.center.x - circle.radius);
+    maxX = Math.max(maxX, circle.center.x + circle.radius);
+    minY = Math.min(minY, circle.center.y - circle.radius);
+    maxY = Math.max(maxY, circle.center.y + circle.radius);
+    found = true;
+  }
+  if (!found) return void 0;
+  const courtyardCenterX = (minX + maxX) / 2;
+  const courtyardCenterY = (minY + maxY) / 2;
+  return {
+    offsetFromCenter: {
+      x: courtyardCenterX - componentCenter.x,
+      y: courtyardCenterY - componentCenter.y
+    },
+    width: maxX - minX,
+    height: maxY - minY
+  };
+};
 var buildPackedComponent = (pcbComponents, componentId, db, getNetworkId, shouldAddInnerObstacles, sourcePortToPadIds = /* @__PURE__ */ new Map(), chipMarginsMap = {}, isStatic = false) => {
   const padInfos = pcbComponents.flatMap((pc) => {
     const pads2 = extractPadInfos(pc, db, getNetworkId);
@@ -3292,12 +3437,18 @@ var buildPackedComponent = (pcbComponents, componentId, db, getNetworkId, should
     };
     pads.push(innerPad);
   }
+  const courtyard = extractCourtyardForComponent({
+    db,
+    pcbComponentIds: pcbComponents.map((pc) => pc.pcb_component_id),
+    componentCenter: center
+  });
   return {
     componentId,
     isStatic,
     center,
     ccwRotationOffset: 0,
-    pads
+    pads,
+    courtyard
   };
 };
 var collectPcbComponents = (node, db) => {
@@ -3474,7 +3625,8 @@ var convertPackOutputToPackInput = (packed) => {
       componentId: pc.componentId,
       availableRotationDegrees: pc.availableRotationDegrees,
       // Preserve rotation constraints
-      pads: pc.pads.map(({ absoluteCenter: _ac, ...rest }) => rest)
+      pads: pc.pads.map(({ absoluteCenter: _ac, ...rest }) => rest),
+      courtyard: pc.courtyard
     }
   }));
   return {

package/package.json

@@ -2,7 +2,7 @@
   "name": "calculate-packing",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.71",
+  "version": "0.0.73",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",
@@ -19,16 +19,16 @@
     "@biomejs/biome": "^2.1.1",
     "@flatten-js/core": "^1.6.2",
     "@react-hook/resize-observer": "^2.0.2",
-    "@tscircuit/circuit-json-util": "^0.0.66",
+    "@tscircuit/circuit-json-util": "^0.0.94",
     "@tscircuit/footprinter": "^0.0.203",
-    "@tscircuit/math-utils": "^0.0.25",
+    "@tscircuit/math-utils": "^0.0.36",
     "@tscircuit/solver-utils": "^0.0.14",
     "@types/bun": "latest",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",
     "@vitejs/plugin-react": "^5.0.0",
     "bun-match-svg": "^0.0.12",
-    "circuit-json": "^0.0.309",
+    "circuit-json": "^0.0.421",
     "framer-motion": "^12.23.12",
     "graphics-debug": "^0.0.78",
     "react": "^19.1.0",