@tscircuit/matchpack 0.0.17 → 0.0.18

package/dist/index.d.ts

@@ -238,7 +238,9 @@ declare class PartitionPackingSolver extends BaseSolver {
     finalLayout: OutputLayout | null;
     packSolver2: PackSolver2 | null;
     constructor(input: PartitionPackingSolverInput);
+    private partitionHasFixedChip;
     _step(): void;
+    private buildConnectivityMap;
     private organizePackedPartitions;
     private createPackInput;
     private applyPackingResult;

package/dist/index.js

@@ -823,9 +823,12 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
   }
   _step() {
     if (!this.activeSubSolver) {
-      const packInput = this.createPackInput();
+      const pinToNetworkMap = createFilteredNetworkMapping({
+        inputProblem: this.partitionInputProblem,
+        pinIdToStronglyConnectedPins: this.pinIdToStronglyConnectedPins
+      }).pinToNetworkMap;
+      const packInput = this.createPackInput(pinToNetworkMap);
       this.activeSubSolver = new PackSolver2(packInput);
-      this.activeSubSolver = this.activeSubSolver;
     }
     this.activeSubSolver.step();
     if (this.activeSubSolver.failed) {
@@ -841,11 +844,7 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
       this.activeSubSolver = null;
     }
   }
-  createPackInput() {
-    const pinToNetworkMap = createFilteredNetworkMapping({
-      inputProblem: this.partitionInputProblem,
-      pinIdToStronglyConnectedPins: this.pinIdToStronglyConnectedPins
-    }).pinToNetworkMap;
+  createPackInput(pinToNetworkMap) {
     const packComponents = Object.entries(
       this.partitionInputProblem.chipMap
     ).map(([chipId, chip]) => {
@@ -860,7 +859,6 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
           type: "rect",
           offset: { x: pin.offset.x, y: pin.offset.y },
           size: { x: PIN_SIZE, y: PIN_SIZE }
-          // Small size for pins
         });
       }
       const padsBoundingBox = getPadsBoundingBox(pads);
@@ -878,10 +876,16 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
           y: Math.max(padsBoundingBoxSize.y, chip.size.y)
         }
       });
+      const fixedRotation = chip.availableRotations?.[0] ?? 0;
       return {
         componentId: chipId,
         pads,
-        availableRotationDegrees: chip.availableRotations || [0, 90, 180, 270]
+        availableRotationDegrees: chip.availableRotations ?? [0, 90, 180, 270],
+        ...chip.fixedPosition && {
+          isStatic: true,
+          center: chip.fixedPosition,
+          ccwRotationOffset: fixedRotation
+        }
       };
     });
     let minGap = this.partitionInputProblem.chipGap;
@@ -902,7 +906,7 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
       chipPlacements[chipId] = {
         x: packedComponent.center.x,
         y: packedComponent.center.y,
-        ccwRotationDegrees: packedComponent.ccwRotationOffset || packedComponent.ccwRotationDegrees || 0
+        ccwRotationDegrees: packedComponent.ccwRotationDegrees ?? packedComponent.ccwRotationOffset ?? 0
       };
     }
     return {
@@ -1007,13 +1011,17 @@ var PartitionPackingSolver = class extends BaseSolver {
     this.packedPartitions = input.packedPartitions;
     this.inputProblem = input.inputProblem;
   }
+  partitionHasFixedChip(partitionIndex) {
+    const packedPartition = this.packedPartitions[partitionIndex];
+    if (!packedPartition) return false;
+    return Object.values(packedPartition.inputProblem.chipMap).some(
+      (chip) => chip.fixedPosition !== void 0
+    );
+  }
   _step() {
     try {
       if (this.packedPartitions.length === 0) {
-        this.finalLayout = {
-          chipPlacements: {},
-          groupPlacements: {}
-        };
+        this.finalLayout = { chipPlacements: {}, groupPlacements: {} };
         this.solved = true;
         return;
       }
@@ -1048,6 +1056,35 @@ var PartitionPackingSolver = class extends BaseSolver {
       this.error = `Failed to pack partitions: ${error}`;
     }
   }
+  buildConnectivityMap() {
+    const pinToNetworkMap = /* @__PURE__ */ new Map();
+    for (const packedPartition of this.packedPartitions) {
+      for (const [connKey, connected] of Object.entries(
+        packedPartition.inputProblem.netConnMap
+      )) {
+        if (!connected) continue;
+        const [pinId, netId] = connKey.split("-");
+        if (pinId && netId) pinToNetworkMap.set(pinId, netId);
+      }
+      for (const [connKey, connected] of Object.entries(
+        packedPartition.inputProblem.pinStrongConnMap
+      )) {
+        if (!connected) continue;
+        const pins = connKey.split("-");
+        if (pins.length === 2 && pins[0] && pins[1]) {
+          const existingNet = pinToNetworkMap.get(pins[0]) || pinToNetworkMap.get(pins[1]);
+          if (existingNet) {
+            pinToNetworkMap.set(pins[0], existingNet);
+            pinToNetworkMap.set(pins[1], existingNet);
+          } else {
+            pinToNetworkMap.set(pins[0], connKey);
+            pinToNetworkMap.set(pins[1], connKey);
+          }
+        }
+      }
+    }
+    return pinToNetworkMap;
+  }
   organizePackedPartitions() {
     const partitionGroups = [];
     for (let i = 0; i < this.packedPartitions.length; i++) {
@@ -1078,47 +1115,20 @@ var PartitionPackingSolver = class extends BaseSolver {
           minY = Math.min(minY, chipMinY);
           maxY = Math.max(maxY, chipMaxY);
         }
-        const bounds = { minX, maxX, minY, maxY };
         partitionGroups.push({
           partitionIndex: i,
           chipIds: partitionChipIds,
-          bounds
+          bounds: { minX, maxX, minY, maxY }
         });
       }
     }
     return partitionGroups;
   }
-  createPackInput(partitionGroups) {
-    const pinToNetworkMap = /* @__PURE__ */ new Map();
-    for (const packedPartition of this.packedPartitions) {
-      for (const [connKey, connected] of Object.entries(
-        packedPartition.inputProblem.netConnMap
-      )) {
-        if (!connected) continue;
-        const [pinId, netId] = connKey.split("-");
-        if (pinId && netId) {
-          pinToNetworkMap.set(pinId, netId);
-        }
-      }
-      for (const [connKey, connected] of Object.entries(
-        packedPartition.inputProblem.pinStrongConnMap
-      )) {
-        if (!connected) continue;
-        const pins = connKey.split("-");
-        if (pins.length === 2 && pins[0] && pins[1]) {
-          const existingNet = pinToNetworkMap.get(pins[0]) || pinToNetworkMap.get(pins[1]);
-          if (existingNet) {
-            pinToNetworkMap.set(pins[0], existingNet);
-            pinToNetworkMap.set(pins[1], existingNet);
-          } else {
-            pinToNetworkMap.set(pins[0], connKey);
-            pinToNetworkMap.set(pins[1], connKey);
-          }
-        }
-      }
-    }
-    const packComponents = partitionGroups.map((group) => {
+  createPackInput(groups) {
+    const pinToNetworkMap = this.buildConnectivityMap();
+    const packComponents = groups.map((group) => {
       const packedPartition = this.packedPartitions[group.partitionIndex];
+      const isFixed = this.partitionHasFixedChip(group.partitionIndex);
       const partitionWidth = group.bounds.maxX - group.bounds.minX;
       const partitionHeight = group.bounds.maxY - group.bounds.minY;
       const centerX = (group.bounds.minX + group.bounds.maxX) / 2;
@@ -1136,37 +1146,32 @@ var PartitionPackingSolver = class extends BaseSolver {
         }
       ];
       const addedNetworks = /* @__PURE__ */ new Set();
-      const pinPositions = /* @__PURE__ */ new Map();
       for (const chipId of group.chipIds) {
         const chipPlacement = packedPartition.layout.chipPlacements[chipId];
         const chip = packedPartition.inputProblem.chipMap[chipId];
         for (const pinId of chip.pins) {
           const chipPin = packedPartition.inputProblem.chipPinMap[pinId];
           if (!chipPin) continue;
-          let transformedOffset = { x: chipPin.offset.x, y: chipPin.offset.y };
-          const rotation = chipPlacement.ccwRotationDegrees || 0;
-          if (rotation === 90) {
-            transformedOffset = { x: -chipPin.offset.y, y: chipPin.offset.x };
-          } else if (rotation === 180) {
-            transformedOffset = { x: -chipPin.offset.x, y: -chipPin.offset.y };
-          } else if (rotation === 270) {
-            transformedOffset = { x: chipPin.offset.y, y: -chipPin.offset.x };
+          let rotatedPinOffset = { x: chipPin.offset.x, y: chipPin.offset.y };
+          const chipRotationDeg = chipPlacement.ccwRotationDegrees ?? 0;
+          if (chipRotationDeg === 90) {
+            rotatedPinOffset = { x: -chipPin.offset.y, y: chipPin.offset.x };
+          } else if (chipRotationDeg === 180) {
+            rotatedPinOffset = { x: -chipPin.offset.x, y: -chipPin.offset.y };
+          } else if (chipRotationDeg === 270) {
+            rotatedPinOffset = { x: chipPin.offset.y, y: -chipPin.offset.x };
           }
-          const absolutePinX = chipPlacement.x + transformedOffset.x;
-          const absolutePinY = chipPlacement.y + transformedOffset.y;
-          pinPositions.set(pinId, { x: absolutePinX, y: absolutePinY });
-          const networkId = pinToNetworkMap.get(pinId) || `${pinId}_disconnected`;
+          const absolutePinX = chipPlacement.x + rotatedPinOffset.x;
+          const absolutePinY = chipPlacement.y + rotatedPinOffset.y;
+          const networkId = pinToNetworkMap.get(pinId) ?? `${pinId}_disconnected`;
           if (!addedNetworks.has(networkId)) {
             addedNetworks.add(networkId);
-            const padOffsetX = absolutePinX - centerX;
-            const padOffsetY = absolutePinY - centerY;
             pads.push({
               padId: `${group.partitionIndex}_pin_${pinId}`,
               networkId,
               type: "rect",
-              offset: { x: padOffsetX, y: padOffsetY },
+              offset: { x: absolutePinX - centerX, y: absolutePinY - centerY },
               size: { x: 0.01, y: 0.01 }
-              // Small pin pad
             });
           }
         }
@@ -1174,14 +1179,17 @@ var PartitionPackingSolver = class extends BaseSolver {
       return {
         componentId: `partition_${group.partitionIndex}`,
         pads,
-        availableRotationDegrees: [0]
-        // Keep partitions unrotated
+        availableRotationDegrees: [0],
+        ...isFixed && {
+          isStatic: true,
+          center: { x: centerX, y: centerY },
+          ccwRotationOffset: 0
+        }
       };
     });
     return {
       components: packComponents,
       minGap: this.inputProblem.partitionGap,
-      // Use partitionGap from input problem
       packOrderStrategy: "largest_to_smallest",
       packPlacementStrategy: "minimum_sum_squared_distance_to_network"
     };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/matchpack",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "files": [
     "dist"
   ],
@@ -14,21 +14,21 @@
     "build:site": "cosmos-export"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.1.3",
+    "@biomejs/biome": "^2.4.16",
     "@react-hook/resize-observer": "^2.0.2",
-    "@tscircuit/circuit-json-util": "^0.0.64",
-    "@tscircuit/math-utils": "^0.0.19",
-    "@tscircuit/schematic-viewer": "^2.0.26",
-    "@types/bun": "latest",
+    "@tscircuit/circuit-json-util": "^0.0.95",
+    "@tscircuit/math-utils": "^0.0.36",
+    "@tscircuit/schematic-viewer": "^2.0.61",
+    "@types/bun": "^1.3.14",
     "bpc-graph": "^0.0.66",
-    "calculate-packing": "^0.0.31",
-    "circuit-json": "^0.0.226",
-    "graphics-debug": "^0.0.64",
-    "react-cosmos": "^7.0.0",
-    "react-cosmos-plugin-vite": "^7.0.0",
-    "tscircuit": "^0.0.593",
-    "tsup": "^8.5.0",
-    "circuit-to-svg": "^0.0.350"
+    "calculate-packing": "^0.0.74",
+    "circuit-json": "^0.0.432",
+    "graphics-debug": "^0.0.95",
+    "react-cosmos": "^7.3.0",
+    "react-cosmos-plugin-vite": "^7.3.0",
+    "tscircuit": "^0.0.1819",
+    "tsup": "^8.5.1",
+    "circuit-to-svg": "^0.0.351"
   },
   "peerDependencies": {
     "typescript": "^5"