calculate-packing 0.0.34 → 0.0.36

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { GraphicsObject, Point as Point$2 } from 'graphics-debug';
 import { CircuitJson } from 'circuit-json';
-import { Bounds, Point as Point$3 } from '@tscircuit/math-utils';
+import { GraphicsObject, Point as Point$3 } from 'graphics-debug';
+import { Bounds, Point as Point$2 } from '@tscircuit/math-utils';
 
 type ComponentId = string;
 type PadId = string;
@@ -43,9 +43,19 @@ interface PackedComponent extends InputComponent {
     ccwRotationDegrees?: number;
     pads: OutputPad[];
 }
+interface InputObstacle {
+    obstacleId: string;
+    absoluteCenter: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+}
 type PackPlacementStrategy = "shortest_connection_along_outline" | "minimum_sum_distance_to_network" | "minimum_sum_squared_distance_to_network" | "minimum_closest_sum_squared_distance";
 interface PackInput {
     components: InputComponent[];
+    obstacles?: InputObstacle[];
     minGap: number;
     packOrderStrategy: "largest_to_smallest";
     packPlacementStrategy: PackPlacementStrategy;
@@ -73,6 +83,34 @@ interface PackOutput extends PackInput {
  */
 declare const pack: (input: PackInput) => PackOutput;
 
+declare const convertCircuitJsonToPackOutput: (circuitJson: CircuitJson, opts?: {
+    source_group_id?: string;
+    shouldAddInnerObstacles?: boolean;
+    chipMarginsMap?: Record<string, {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    }>;
+}) => PackOutput;
+
+declare const getGraphicsFromPackOutput: (packOutput: PackOutput) => GraphicsObject;
+
+/**
+ * Strip all “output only” properties (those added by the pack() solver)
+ * so the result can be fed back into pack() again or compared against an
+ * original PackInput.  Everything else must be preserved verbatim.
+ *
+ * NOTE:
+ * – PackInput.components is an array of **InputComponent**,
+ *   while PackOutput.components is an array of **PackedComponent**.
+ *   We therefore have to:
+ *     • copy componentId
+ *     • copy each pad but drop `absoluteCenter`
+ *     • drop `center` and `ccwRotationOffset`
+ */
+declare const convertPackOutputToPackInput: (packed: PackOutput) => PackInput;
+
 declare class BaseSolver {
     MAX_ITERATIONS: number;
     solved: boolean;
@@ -113,90 +151,6 @@ type Point$1 = {
 };
 type Segment = [Point$1, Point$1];
 
-type PackingPhase = "idle" | "show_candidate_points" | "show_rotations" | "show_final_placement";
-interface RotationTrial extends PackedComponent {
-    cost: number;
-    anchorType: "pad" | "center";
-    anchorPadId?: string;
-    hasOverlap: boolean;
-}
-declare class PhasedPackSolver extends BaseSolver {
-    packInput: PackInput;
-    unpackedComponentQueue: InputComponent[];
-    packedComponents: PackedComponent[];
-    currentPhase: PackingPhase;
-    currentComponent?: InputComponent;
-    phaseData: {
-        candidatePoints?: Array<Point$2 & {
-            networkId: NetworkId;
-            distance: number;
-        }>;
-        goodCandidates?: Array<Point$2 & {
-            networkId: NetworkId;
-        }>;
-        bestDistance?: number;
-        rotationTrials?: Array<RotationTrial>;
-        selectedRotation?: PackedComponent;
-        outlines?: Segment[][];
-    };
-    lastBestPointsResult?: {
-        goodCandidates: (Point$2 & {
-            networkId: NetworkId;
-        })[];
-        distance: number;
-    };
-    lastEvaluatedPositionShadows?: Array<PackedComponent>;
-    lastCandidatePoints?: Array<Point$2 & {
-        networkId: NetworkId;
-        distance: number;
-    }>;
-    constructor(input: PackInput);
-    _setup(): void;
-    _step(): void;
-    private placeFirstComponent;
-    private computeCandidatePoints;
-    private computeRotationTrials;
-    private selectBestRotation;
-    private finalizeComponentPlacement;
-    /** Visualize the current packing state based on the current phase */
-    visualize(): GraphicsObject;
-    private visualizeCandidatePoints;
-    private visualizeRotationTrials;
-    private visualizeFinalPlacement;
-    getConstructorParams(): PackInput[];
-    getResult(): PackedComponent[];
-    private getCandidateAngles;
-    private checkOverlapWithPackedComponents;
-}
-
-declare const convertCircuitJsonToPackOutput: (circuitJson: CircuitJson, opts?: {
-    source_group_id?: string;
-    shouldAddInnerObstacles?: boolean;
-    chipMarginsMap?: Record<string, {
-        left: number;
-        right: number;
-        top: number;
-        bottom: number;
-    }>;
-}) => PackOutput;
-
-declare const getGraphicsFromPackOutput: (packOutput: PackOutput) => GraphicsObject;
-
-/**
- * Strip all “output only” properties (those added by the pack() solver)
- * so the result can be fed back into pack() again or compared against an
- * original PackInput.  Everything else must be preserved verbatim.
- *
- * NOTE:
- * – PackInput.components is an array of **InputComponent**,
- *   while PackOutput.components is an array of **PackedComponent**.
- *   We therefore have to:
- *     • copy componentId
- *     • copy each pad but drop `absoluteCenter`
- *     • drop `center` and `ccwRotationOffset`
- */
-declare const convertPackOutputToPackInput: (packed: PackOutput) => PackInput;
-
 type Rect = {
     x: number;
     y: number;
@@ -387,26 +341,28 @@ declare class TwoPhaseIrlsSolver extends BaseSolver {
  * an interactive visualization of how it works.
  */
 declare class OutlineSegmentCandidatePointSolver extends BaseSolver {
-    outlineSegment: [Point$3, Point$3];
-    viableOutlineSegment: [Point$3, Point$3] | null;
-    fullOutline: [Point$3, Point$3][];
+    outlineSegment: [Point$2, Point$2];
+    viableOutlineSegment: [Point$2, Point$2] | null;
+    fullOutline: [Point$2, Point$2][];
     componentRotationDegrees: number;
     packStrategy: PackPlacementStrategy;
     minGap: number;
+    obstacles: InputObstacle[];
     packedComponents: PackedComponent[];
     componentToPack: InputComponent;
     viableBounds?: Bounds;
-    optimalPosition?: Point$3;
+    optimalPosition?: Point$2;
     irlsSolver?: MultiOffsetIrlsSolver;
     twoPhaseIrlsSolver?: TwoPhaseIrlsSolver;
     constructor(params: {
-        outlineSegment: [Point$3, Point$3];
-        fullOutline: [Point$3, Point$3][];
+        outlineSegment: [Point$2, Point$2];
+        fullOutline: [Point$2, Point$2][];
         componentRotationDegrees: number;
         packStrategy: PackPlacementStrategy;
         minGap: number;
         packedComponents: PackedComponent[];
         componentToPack: InputComponent;
+        obstacles?: InputObstacle[];
     });
     getConstructorParams(): ConstructorParameters<typeof OutlineSegmentCandidatePointSolver>[0];
     _getOutlineBoundsWithMargin(params?: {
@@ -452,7 +408,7 @@ interface QueuedOutlineSegment {
 interface CandidateResult {
     segment: Segment;
     rotation: number;
-    optimalPosition?: Point$2;
+    optimalPosition?: Point$3;
     distance: number;
     segmentIndex: number;
     rotationIndex: number;
@@ -475,6 +431,7 @@ declare class SingleComponentPackSolver extends BaseSolver {
     packedComponents: PackedComponent[];
     packPlacementStrategy: PackPlacementStrategy;
     minGap: number;
+    obstacles: InputObstacle[];
     currentPhase: Phase;
     outlines: Segment[][];
     queuedOutlineSegments: QueuedOutlineSegment[];
@@ -492,6 +449,7 @@ declare class SingleComponentPackSolver extends BaseSolver {
         packedComponents: PackedComponent[];
         packPlacementStrategy: PackPlacementStrategy;
         minGap?: number;
+        obstacles?: InputObstacle[];
     });
     _setup(): void;
     _step(): void;
@@ -510,6 +468,7 @@ declare class SingleComponentPackSolver extends BaseSolver {
         packedComponents: PackedComponent[];
         packPlacementStrategy: PackPlacementStrategy;
         minGap: number;
+        obstacles: InputObstacle[];
     };
 }
 
@@ -527,4 +486,4 @@ declare class PackSolver2 extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-export { type ComponentId, type GlobalBounds, type InputComponent, type InputPad, LargestRectOutsideOutlineFromPointSolver, type NetworkId, type OutputPad, type PackInput, type PackOutput, type PackPlacementStrategy, PackSolver2, type PackedComponent, type PadId, PhasedPackSolver, type Point$1 as Point, type Rect, convertCircuitJsonToPackOutput, convertPackOutputToPackInput, getGraphicsFromPackOutput, pack };
+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 };