@pooder/kit 3.1.0 → 3.2.0

package/src/hole.ts

@@ -152,12 +152,22 @@ export class HoleTool implements Extension {
           title: "Add Hole",
           handler: (x: number, y: number) => {
             if (!this.canvasService) return false;
-            const { width, height } = this.canvasService.canvas;
             
-            const normalizedHole = Coordinate.normalizePoint(
-              { x, y },
-              { width: width || 800, height: height || 600 }
-            );
+            // Normalize relative to Dieline Geometry if available
+            let normalizedX = 0.5;
+            let normalizedY = 0.5;
+
+            if (this.currentGeometry) {
+                const { x: gx, y: gy, width: gw, height: gh } = this.currentGeometry;
+                const left = gx - gw / 2;
+                const top = gy - gh / 2;
+                normalizedX = gw > 0 ? (x - left) / gw : 0.5;
+                normalizedY = gh > 0 ? (y - top) / gh : 0.5;
+            } else {
+                 const { width, height } = this.canvasService.canvas;
+                 normalizedX = Coordinate.toNormalized(x, width || 800);
+                 normalizedY = Coordinate.toNormalized(y, height || 600);
+            }
 
             const configService = this.context?.services.get<ConfigurationService>(
               "ConfigurationService"
@@ -171,8 +181,8 @@ export class HoleTool implements Extension {
               const outerRadius = lastHole?.outerRadius ?? 25;
 
               const newHole = {
-                  x: normalizedHole.x,
-                  y: normalizedHole.y,
+                  x: normalizedX,
+                  y: normalizedY,
                   innerRadius,
                   outerRadius,
               };
@@ -294,7 +304,14 @@ export class HoleTool implements Extension {
         if (!target || target.data?.type !== "hole-marker") return;
 
         // Update state when hole is moved
-        this.syncHolesFromCanvas();
+        // Ensure final position is constrained (handles case where 'modified' reports unconstrained coords)
+        const changed = this.enforceConstraints();
+        
+        // If enforceConstraints changed something, it already synced.
+        // If not, we sync manually to save the move (which was valid).
+        if (!changed) {
+          this.syncHolesFromCanvas();
+        }
       };
       canvas.on("object:modified", this.handleModified);
     }
@@ -365,6 +382,11 @@ export class HoleTool implements Extension {
       const newAbsX = obj.left!;
       const newAbsY = obj.top!;
 
+      // Get current scale to denormalize offsets
+      const scale = this.currentGeometry?.scale || 1;
+      const unit = this.currentGeometry?.unit || "mm";
+      const unitScale = Coordinate.convertUnit(1, "mm", unit);
+
       if (original && original.anchor && this.currentGeometry) {
         // Reverse calculate offset from anchor
         const { x, y, width, height } = this.currentGeometry;
@@ -416,25 +438,37 @@ export class HoleTool implements Extension {
         
         return {
           ...original,
-          offsetX: newAbsX - bx,
-          offsetY: newAbsY - by,
+          // Denormalize offset back to physical units (mm)
+          offsetX: (newAbsX - bx) / scale / unitScale,
+          offsetY: (newAbsY - by) / scale / unitScale,
           // Clear direct coordinates if we use anchor
           x: undefined,
           y: undefined,
         };
       }
 
-      // If no anchor, use normalized coordinates
-      const { width, height } = this.canvasService!.canvas;
-      const p = Coordinate.normalizePoint(
-        { x: newAbsX, y: newAbsY },
-        { width: width || 800, height: height || 600 }
-      );
+      // If no anchor, use normalized coordinates relative to Dieline Geometry
+      // normalized = (absolute - (center - width/2)) / width
+      let normalizedX = 0.5;
+      let normalizedY = 0.5;
+
+      if (this.currentGeometry) {
+        const { x, y, width, height } = this.currentGeometry;
+        const left = x - width / 2;
+        const top = y - height / 2;
+        normalizedX = width > 0 ? (newAbsX - left) / width : 0.5;
+        normalizedY = height > 0 ? (newAbsY - top) / height : 0.5;
+      } else {
+        // Fallback to Canvas normalization if no geometry (should rare)
+        const { width, height } = this.canvasService!.canvas;
+        normalizedX = Coordinate.toNormalized(newAbsX, width || 800);
+        normalizedY = Coordinate.toNormalized(newAbsY, height || 600);
+      }
       
       return {
         ...original,
-        x: p.x,
-        y: p.y,
+        x: normalizedX,
+        y: normalizedY,
         // Ensure radii are preserved
         innerRadius: original?.innerRadius ?? 15,
         outerRadius: original?.outerRadius ?? 25,
@@ -486,18 +520,32 @@ export class HoleTool implements Extension {
       y: (height || 600) / 2,
       width: width || 800,
       height: height || 600,
-    };
+      scale: 1, // Default scale if no geometry loaded
+    } as any;
 
     holes.forEach((hole, index) => {
+      // Geometry scale is needed.
+      const scale = geometry.scale || 1;
+      const unit = geometry.unit || "mm";
+      const unitScale = Coordinate.convertUnit(1, 'mm', unit);
+      
+      const visualInnerRadius = hole.innerRadius * unitScale * scale;
+      const visualOuterRadius = hole.outerRadius * unitScale * scale;
+
       // Resolve position
+      // Apply unit conversion and scale to offsets before resolving (mm -> px)
       const pos = resolveHolePosition(
-        hole,
+        {
+          ...hole,
+          offsetX: (hole.offsetX || 0) * unitScale * scale,
+          offsetY: (hole.offsetY || 0) * unitScale * scale,
+        },
         geometry,
-        { width: width || 800, height: height || 600 }
+        { width: geometry.width, height: geometry.height } // Use geometry dims instead of canvas
       );
 
       const innerCircle = new Circle({
-        radius: hole.innerRadius,
+        radius: visualInnerRadius,
         fill: "transparent",
         stroke: "red",
         strokeWidth: 2,
@@ -506,7 +554,7 @@ export class HoleTool implements Extension {
       });
 
       const outerCircle = new Circle({
-        radius: hole.outerRadius,
+        radius: visualOuterRadius,
         fill: "transparent",
         stroke: "#666",
         strokeWidth: 1,
@@ -592,14 +640,23 @@ export class HoleTool implements Extension {
     objects.forEach((obj: any, i: number) => {
       const currentPos = new Point(obj.left, obj.top);
       // We need to pass the hole's radii to calculateConstrainedPosition
-      const holeData = this.holes[i];
-      
-      const newPos = this.calculateConstrainedPosition(
-        currentPos,
-        constraintGeometry,
-        holeData?.innerRadius ?? 15,
-        holeData?.outerRadius ?? 25
-      );
+    const holeData = this.holes[i];
+    
+    // Scale radii for constraint calculation (since geometry is in pixels)
+    // Geometry scale is needed.
+    const scale = geometry.scale || 1;
+    const unit = geometry.unit || "mm";
+    const unitScale = Coordinate.convertUnit(1, 'mm', unit);
+    
+    const innerR = (holeData?.innerRadius ?? 15) * unitScale * scale;
+    const outerR = (holeData?.outerRadius ?? 25) * unitScale * scale;
+
+    const newPos = this.calculateConstrainedPosition(
+      currentPos,
+      constraintGeometry,
+      innerR,
+      outerR
+    );
 
       if (currentPos.distanceFrom(newPos) > 0.1) {
         obj.set({