calculate-packing 0.0.48 → 0.0.50

package/dist/index.js

@@ -2196,6 +2196,11 @@ var SingleComponentPackSolver = class extends BaseSolver {
             return distance2 + 1e-6 < this.minGap;
           });
         });
+        let outsideBounds = false;
+        if (this.bounds) {
+          const componentBounds = getComponentBounds(candidateComponent, 0);
+          outsideBounds = componentBounds.minX < this.bounds.minX || componentBounds.maxX > this.bounds.maxX || componentBounds.minY < this.bounds.minY || componentBounds.maxY > this.bounds.maxY;
+        }
         let outsideBoundaryOutline = false;
         if (this.boundaryOutline && this.boundaryOutline.length >= 3) {
           const componentBounds = getComponentBounds(candidateComponent, 0);
@@ -2231,6 +2236,17 @@ var SingleComponentPackSolver = class extends BaseSolver {
             rotationIndex: this.currentRotationIndex,
             gapDistance: minObstacleGapDistance
           });
+        } else if (outsideBounds) {
+          this.rejectedCandidates.push({
+            segment: queuedSegment.segment,
+            rotation,
+            optimalPosition,
+            distance,
+            segmentIndex: queuedSegment.segmentIndex,
+            rotationIndex: this.currentRotationIndex,
+            gapDistance: -1
+            // Special marker for bounds violation
+          });
         } else if (outsideBoundaryOutline) {
           this.rejectedCandidates.push({
             segment: queuedSegment.segment,
@@ -2503,6 +2519,38 @@ gap_distance=${candidate.gapDistance}`,
 
 // lib/PackSolver2/PackSolver2.ts
 import { computeDistanceBetweenBoxes as computeDistanceBetweenBoxes3 } from "@tscircuit/math-utils";
+
+// lib/math/getPolygonCentroid.ts
+function getPolygonCentroid(points) {
+  if (points.length < 3) {
+    const sumX = points.reduce((sum, p) => sum + p.x, 0);
+    const sumY = points.reduce((sum, p) => sum + p.y, 0);
+    return { x: sumX / points.length, y: sumY / points.length };
+  }
+  let signedArea = 0;
+  let cx = 0;
+  let cy = 0;
+  for (let i = 0; i < points.length; i++) {
+    const p1 = points[i];
+    const p2 = points[(i + 1) % points.length];
+    const crossProduct = p1.x * p2.y - p2.x * p1.y;
+    signedArea += crossProduct;
+    cx += (p1.x + p2.x) * crossProduct;
+    cy += (p1.y + p2.y) * crossProduct;
+  }
+  signedArea *= 0.5;
+  const area = Math.abs(signedArea);
+  if (area < 1e-10) {
+    const sumX = points.reduce((sum, p) => sum + p.x, 0);
+    const sumY = points.reduce((sum, p) => sum + p.y, 0);
+    return { x: sumX / points.length, y: sumY / points.length };
+  }
+  cx /= 6 * signedArea;
+  cy /= 6 * signedArea;
+  return { x: cx, y: cy };
+}
+
+// lib/PackSolver2/PackSolver2.ts
 var PackSolver2 = class extends BaseSolver {
   packInput;
   unpackedComponentQueue = [];
@@ -2526,9 +2574,13 @@ var PackSolver2 = class extends BaseSolver {
   }
   packFirstComponent() {
     const firstComponentToPack = this.unpackedComponentQueue.shift();
+    let initialPosition = { x: 0, y: 0 };
+    if (this.packInput.boundaryOutline && this.packInput.boundaryOutline.length >= 3) {
+      initialPosition = getPolygonCentroid(this.packInput.boundaryOutline);
+    }
     const newPackedComponent = {
       ...firstComponentToPack,
-      center: { x: 0, y: 0 },
+      center: initialPosition,
       ccwRotationOffset: 0,
       pads: firstComponentToPack.pads.map((p) => ({
         ...p,
@@ -2553,7 +2605,23 @@ var PackSolver2 = class extends BaseSolver {
         return distance + 1e-6 < this.packInput.minGap;
       });
     });
-    if (!tooCloseToObstacles) {
+    let outsideBoundaryOutline = false;
+    if (this.packInput.boundaryOutline && this.packInput.boundaryOutline.length >= 3) {
+      const componentBounds = getComponentBounds(newPackedComponent, 0);
+      const allPadsInside = newPackedComponent.pads.every(
+        (pad) => isPointInPolygon(pad.absoluteCenter, this.packInput.boundaryOutline)
+      );
+      const cornersInside = [
+        { x: componentBounds.minX, y: componentBounds.minY },
+        { x: componentBounds.minX, y: componentBounds.maxY },
+        { x: componentBounds.maxX, y: componentBounds.minY },
+        { x: componentBounds.maxX, y: componentBounds.maxY }
+      ].every(
+        (corner) => isPointInPolygon(corner, this.packInput.boundaryOutline)
+      );
+      outsideBoundaryOutline = !allPadsInside || !cornersInside;
+    }
+    if (!tooCloseToObstacles && !outsideBoundaryOutline) {
       this.packedComponents.push(newPackedComponent);
       return;
     }

package/package.json

@@ -2,7 +2,7 @@
   "name": "calculate-packing",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",