@pooder/kit 4.1.0 → 4.3.0

package/src/feature.ts

@@ -3,7 +3,6 @@ import {
   ExtensionContext,
   ContributionPointIds,
   CommandContribution,
-  ConfigurationContribution,
   ConfigurationService,
 } from "@pooder/core";
 import { Circle, Group, Point, Rect } from "fabric";
@@ -14,8 +13,11 @@ import {
   DielineFeature,
   resolveFeaturePosition,
 } from "./geometry";
-import { Coordinate } from "./coordinate";
-import { ConstraintRegistry } from "./constraints";
+import { ConstraintRegistry, ConstraintFeature } from "./constraints";
+import {
+  completeFeaturesStrict,
+} from "./featureComplete";
+import { parseLengthToMm } from "./units";
 
 export class FeatureTool implements Extension {
   id = "pooder.kit.feature";
@@ -24,7 +26,7 @@ export class FeatureTool implements Extension {
     name: "FeatureTool",
   };
 
-  private features: DielineFeature[] = [];
+  private workingFeatures: ConstraintFeature[] = [];
   private canvasService?: CanvasService;
   private context?: ExtensionContext;
   private isUpdatingConfig = false;
@@ -39,7 +41,7 @@ export class FeatureTool implements Extension {
 
   constructor(
     options?: Partial<{
-      features: DielineFeature[];
+      features: ConstraintFeature[];
     }>,
   ) {
     if (options) {
@@ -60,14 +62,18 @@ export class FeatureTool implements Extension {
       "ConfigurationService",
     );
     if (configService) {
-      this.features = configService.get("dieline.features", []);
+      const features = (configService.get("dieline.features", []) ||
+        []) as ConstraintFeature[];
+      this.workingFeatures = this.cloneFeatures(features);
 
       configService.onAnyChange((e: { key: string; value: any }) => {
         if (this.isUpdatingConfig) return;
 
         if (e.key === "dieline.features") {
-          this.features = e.value || [];
+          const next = (e.value || []) as ConstraintFeature[];
+          this.workingFeatures = this.cloneFeatures(next);
           this.redraw();
+          this.emitWorkingChange();
         }
       });
     }
@@ -138,104 +144,240 @@ export class FeatureTool implements Extension {
           command: "clearFeatures",
           title: "Clear Features",
           handler: () => {
-            const configService =
-              this.context?.services.get<ConfigurationService>(
-                "ConfigurationService",
-              );
-            if (configService) {
-              configService.update("dieline.features", []);
-            }
+            this.setWorkingFeatures([]);
+            this.redraw();
+            this.emitWorkingChange();
             return true;
           },
         },
+        {
+          command: "getWorkingFeatures",
+          title: "Get Working Features",
+          handler: () => {
+            return this.cloneFeatures(this.workingFeatures);
+          },
+        },
+        {
+          command: "setWorkingFeatures",
+          title: "Set Working Features",
+          handler: async (features: ConstraintFeature[]) => {
+            await this.refreshGeometry();
+            this.setWorkingFeatures(this.cloneFeatures(features || []));
+            this.redraw();
+            this.emitWorkingChange();
+            return { ok: true };
+          },
+        },
+        {
+          command: "updateWorkingGroupPosition",
+          title: "Update Working Group Position",
+          handler: (groupId: string, x: number, y: number) => {
+            return this.updateWorkingGroupPosition(groupId, x, y);
+          },
+        },
+        {
+          command: "completeFeatures",
+          title: "Complete Features",
+          handler: () => {
+            return this.completeFeatures();
+          },
+        },
       ] as CommandContribution[],
     };
   }
 
-  private addFeature(type: "add" | "subtract") {
-    if (!this.canvasService) return false;
+  private cloneFeatures(features: ConstraintFeature[]): ConstraintFeature[] {
+    return JSON.parse(JSON.stringify(features || [])) as ConstraintFeature[];
+  }
 
-    const configService = this.context?.services.get<ConfigurationService>(
-      "ConfigurationService",
+  private emitWorkingChange() {
+    this.context?.eventBus.emit("feature:working:change", {
+      features: this.cloneFeatures(this.workingFeatures),
+    });
+  }
+
+  private async refreshGeometry() {
+    if (!this.context) return;
+    const commandService = this.context.services.get<any>("CommandService");
+    if (!commandService) return;
+    try {
+      const g = await Promise.resolve(commandService.executeCommand("getGeometry"));
+      if (g) this.currentGeometry = g as DielineGeometry;
+    } catch (e) {}
+  }
+
+  private setWorkingFeatures(next: ConstraintFeature[]) {
+    this.workingFeatures = next;
+  }
+
+  private updateWorkingGroupPosition(groupId: string, x: number, y: number) {
+    if (!groupId) return { ok: false };
+
+    const configService =
+      this.context?.services.get<ConfigurationService>("ConfigurationService");
+    if (!configService) return { ok: false };
+
+    const dielineWidth = parseLengthToMm(
+      configService.get("dieline.width") ?? 500,
+      "mm",
+    );
+    const dielineHeight = parseLengthToMm(
+      configService.get("dieline.height") ?? 500,
+      "mm",
+    );
+
+    let changed = false;
+    const next = this.workingFeatures.map((f) => {
+      if (f.groupId !== groupId) return f;
+      let nx = x;
+      let ny = y;
+      if (f.constraints && dielineWidth > 0 && dielineHeight > 0) {
+        const constrained = ConstraintRegistry.apply(nx, ny, f, {
+          dielineWidth,
+          dielineHeight,
+        });
+        nx = constrained.x;
+        ny = constrained.y;
+      }
+
+      if (f.x !== nx || f.y !== ny) {
+        changed = true;
+        return { ...f, x: nx, y: ny };
+      }
+      return f;
+    });
+
+    if (!changed) return { ok: true };
+
+    this.setWorkingFeatures(next);
+    this.redraw();
+    this.enforceConstraints();
+    this.emitWorkingChange();
+
+    return { ok: true };
+  }
+
+  private completeFeatures(): {
+    ok: boolean;
+    issues?: Array<{
+      featureId: string;
+      groupId?: string;
+      reason: string;
+    }>;
+  } {
+    const configService =
+      this.context?.services.get<ConfigurationService>("ConfigurationService");
+    if (!configService) {
+      return {
+        ok: false,
+        issues: [
+          { featureId: "unknown", reason: "ConfigurationService not found" },
+        ],
+      };
+    }
+
+    const dielineWidth = parseLengthToMm(
+      configService.get("dieline.width") ?? 500,
+      "mm",
+    );
+    const dielineHeight = parseLengthToMm(
+      configService.get("dieline.height") ?? 500,
+      "mm",
+    );
+
+    const result = completeFeaturesStrict(
+      this.workingFeatures,
+      { dielineWidth, dielineHeight },
+      (next) => {
+        this.isUpdatingConfig = true;
+        try {
+          configService.update("dieline.features", next);
+        } finally {
+          this.isUpdatingConfig = false;
+        }
+
+        this.workingFeatures = this.cloneFeatures(next as any);
+        this.emitWorkingChange();
+      },
     );
-    const unit = configService?.get("dieline.unit", "mm") || "mm";
-    const defaultSize = Coordinate.convertUnit(10, "mm", unit);
+
+    if (!result.ok) {
+      return {
+        ok: false,
+        issues: result.issues,
+      };
+    }
+
+    return { ok: true };
+  }
+
+  private addFeature(type: "add" | "subtract") {
+    if (!this.canvasService) return false;
 
     // Default to top edge center
-    const newFeature: DielineFeature = {
+    const newFeature: ConstraintFeature = {
       id: Date.now().toString(),
       operation: type,
-      placement: "edge",
       shape: "rect",
       x: 0.5,
       y: 0, // Top edge
-      width: defaultSize,
-      height: defaultSize,
+      width: 10,
+      height: 10,
       rotation: 0,
+      renderBehavior: "edge",
+      // Default constraint: path (snap to edge)
+      constraints: [{ type: "path" }],
     };
 
-    if (configService) {
-      const current = configService.get(
-        "dieline.features",
-        [],
-      ) as DielineFeature[];
-      configService.update("dieline.features", [...current, newFeature]);
-    }
+    this.setWorkingFeatures([...(this.workingFeatures || []), newFeature]);
+    this.redraw();
+    this.emitWorkingChange();
     return true;
   }
 
   private addDoubleLayerHole() {
     if (!this.canvasService) return false;
 
-    const configService = this.context?.services.get<ConfigurationService>(
-      "ConfigurationService",
-    );
-    const unit = configService?.get("dieline.unit", "mm") || "mm";
-    const lugRadius = Coordinate.convertUnit(20, "mm", unit);
-    const holeRadius = Coordinate.convertUnit(15, "mm", unit);
-
     const groupId = Date.now().toString();
     const timestamp = Date.now();
 
     // 1. Lug (Outer) - Add
-    const lug: DielineFeature = {
+    const lug: ConstraintFeature = {
       id: `${timestamp}-lug`,
       groupId,
       operation: "add",
       shape: "circle",
-      placement: "edge",
       x: 0.5,
       y: 0,
-      radius: lugRadius, // 20mm
+      radius: 20,
       rotation: 0,
+      renderBehavior: "edge",
+      constraints: [{ type: "path" }],
     };
 
     // 2. Hole (Inner) - Subtract
-    const hole: DielineFeature = {
+    const hole: ConstraintFeature = {
       id: `${timestamp}-hole`,
       groupId,
       operation: "subtract",
       shape: "circle",
-      placement: "edge",
       x: 0.5,
       y: 0,
-      radius: holeRadius, // 15mm
+      radius: 15,
       rotation: 0,
+      renderBehavior: "edge",
+      constraints: [{ type: "path" }],
     };
 
-    if (configService) {
-      const current = configService.get(
-        "dieline.features",
-        [],
-      ) as DielineFeature[];
-      configService.update("dieline.features", [...current, lug, hole]);
-    }
+    this.setWorkingFeatures([...(this.workingFeatures || []), lug, hole]);
+    this.redraw();
+    this.emitWorkingChange();
     return true;
   }
 
   private getGeometryForFeature(
     geometry: DielineGeometry,
-    feature?: DielineFeature,
+    feature?: ConstraintFeature,
   ): DielineGeometry {
     // Legacy support or specialized scaling can go here if needed
     // Currently all features operate on the base geometry (or scaled version of it)
@@ -282,16 +424,16 @@ export class FeatureTool implements Extension {
         if (!this.currentGeometry) return;
 
         // Determine feature to use for snapping context
-        let feature: DielineFeature | undefined;
+        let feature: ConstraintFeature | undefined;
         if (target.data?.isGroup) {
           const indices = target.data?.indices as number[];
           if (indices && indices.length > 0) {
-            feature = this.features[indices[0]];
+            feature = this.workingFeatures[indices[0]];
           }
         } else {
           const index = target.data?.index;
           if (index !== undefined) {
-            feature = this.features[index];
+            feature = this.workingFeatures[index];
           }
         }
 
@@ -327,7 +469,6 @@ export class FeatureTool implements Extension {
         const target = e.target;
         if (!target || target.data?.type !== "feature-marker") return;
 
-        // Sync changes back to config
         if (target.data?.isGroup) {
           // It's a Group object
           const groupObj = target as Group;
@@ -345,7 +486,7 @@ export class FeatureTool implements Extension {
           // Simplified: just add relative coordinates if no rotation/scaling on group
           // We locked rotation/scaling, so it's safe.
 
-          const newFeatures = [...this.features];
+          const newFeatures = [...this.workingFeatures];
           const { x, y } = this.currentGeometry!; // Center is same
 
           // Fabric Group objects have .getObjects() which returns children
@@ -354,7 +495,7 @@ export class FeatureTool implements Extension {
 
           groupObj.getObjects().forEach((child, i) => {
             const originalIndex = indices[i];
-            const feature = this.features[originalIndex];
+            const feature = this.workingFeatures[originalIndex];
             const geometry = this.getGeometryForFeature(
               this.currentGeometry!,
               feature,
@@ -379,20 +520,8 @@ export class FeatureTool implements Extension {
             };
           });
 
-          this.features = newFeatures;
-
-          const configService =
-            this.context?.services.get<ConfigurationService>(
-              "ConfigurationService",
-            );
-          if (configService) {
-            this.isUpdatingConfig = true;
-            try {
-              configService.update("dieline.features", this.features);
-            } finally {
-              this.isUpdatingConfig = false;
-            }
-          }
+          this.setWorkingFeatures(newFeatures);
+          this.emitWorkingChange();
         } else {
           // Single object
           this.syncFeatureFromCanvas(target);
@@ -434,69 +563,42 @@ export class FeatureTool implements Extension {
     p: Point,
     geometry: DielineGeometry,
     limit: number,
-    feature?: DielineFeature
+    feature?: ConstraintFeature
   ): { x: number; y: number } {
-    if (feature && feature.constraints) {
-      // Use Constraint Registry
-      // Convert to normalized coordinates
-      const minX = geometry.x - geometry.width / 2;
-      const minY = geometry.y - geometry.height / 2;
-      
-      const nx = geometry.width > 0 ? (p.x - minX) / geometry.width : 0.5;
-      const ny = geometry.height > 0 ? (p.y - minY) / geometry.height : 0.5;
+    if (!feature) {
+      return { x: p.x, y: p.y };
+    }
 
-      const scale = geometry.scale || 1;
-      const dielineWidth = geometry.width / scale;
-      const dielineHeight = geometry.height / scale;
+    const minX = geometry.x - geometry.width / 2;
+    const minY = geometry.y - geometry.height / 2;
 
-      const constrained = ConstraintRegistry.apply(nx, ny, feature, {
-        dielineWidth,
-        dielineHeight,
-      });
+    // Normalize
+    const nx = geometry.width > 0 ? (p.x - minX) / geometry.width : 0.5;
+    const ny = geometry.height > 0 ? (p.y - minY) / geometry.height : 0.5;
 
-      return {
-        x: minX + constrained.x * geometry.width,
-        y: minY + constrained.y * geometry.height,
-      };
-    }
+    const scale = geometry.scale || 1;
+    const dielineWidth = geometry.width / scale;
+    const dielineHeight = geometry.height / scale;
 
-    if (feature && feature.placement === "internal") {
-       // Constrain to bounds
-       // geometry.x/y is center
-       const minX = geometry.x - geometry.width / 2;
-       const maxX = geometry.x + geometry.width / 2;
-       const minY = geometry.y - geometry.height / 2;
-       const maxY = geometry.y + geometry.height / 2;
-       
-       return {
-         x: Math.max(minX, Math.min(maxX, p.x)),
-         y: Math.max(minY, Math.min(maxY, p.y))
-       };
-    }
+    // Filter constraints: only apply those that are NOT validateOnly
+    const activeConstraints = feature.constraints?.filter((c) => !c.validateOnly);
 
-    // Use geometry helper to find nearest point on Base Shape
-    // geometry object matches GeometryOptions structure required by getNearestPointOnDieline
-    // except for 'features' which we don't need for base shape snapping
-    const nearest = getNearestPointOnDieline({ x: p.x, y: p.y }, {
-      ...geometry,
-      features: [],
-    } as any);
-
-    // Calculate vector from nearest point to current point
-    const dx = p.x - nearest.x;
-    const dy = p.y - nearest.y;
-    const dist = Math.sqrt(dx * dx + dy * dy);
-
-    // If within limit, allow current position (offset from edge)
-    if (dist <= limit) {
-      return { x: p.x, y: p.y };
-    }
+    const constrained = ConstraintRegistry.apply(
+      nx,
+      ny,
+      feature,
+      {
+        dielineWidth,
+        dielineHeight,
+        geometry,
+      },
+      activeConstraints,
+    );
 
-    // Otherwise, clamp to limit
-    const scale = limit / dist;
+    // Denormalize
     return {
-      x: nearest.x + dx * scale,
-      y: nearest.y + dy * scale,
+      x: minX + constrained.x * geometry.width,
+      y: minY + constrained.y * geometry.height,
     };
   }
 
@@ -504,10 +606,14 @@ export class FeatureTool implements Extension {
     if (!this.currentGeometry || !this.context) return;
 
     const index = target.data?.index;
-    if (index === undefined || index < 0 || index >= this.features.length)
+    if (
+      index === undefined ||
+      index < 0 ||
+      index >= this.workingFeatures.length
+    )
       return;
 
-    const feature = this.features[index];
+    const feature = this.workingFeatures[index];
     const geometry = this.getGeometryForFeature(this.currentGeometry, feature);
     const { width, height, x, y } = geometry;
 
@@ -527,22 +633,10 @@ export class FeatureTool implements Extension {
       // Could also update rotation if we allowed rotating markers
     };
 
-    const newFeatures = [...this.features];
+    const newFeatures = [...this.workingFeatures];
     newFeatures[index] = updatedFeature;
-    this.features = newFeatures;
-
-    // Save to config
-    const configService = this.context.services.get<ConfigurationService>(
-      "ConfigurationService",
-    );
-    if (configService) {
-      this.isUpdatingConfig = true;
-      try {
-        configService.update("dieline.features", this.features);
-      } finally {
-        this.isUpdatingConfig = false;
-      }
-    }
+    this.setWorkingFeatures(newFeatures);
+    this.emitWorkingChange();
   }
 
   private redraw() {
@@ -556,7 +650,7 @@ export class FeatureTool implements Extension {
       .filter((obj: any) => obj.data?.type === "feature-marker");
     existing.forEach((obj) => canvas.remove(obj));
 
-    if (!this.features || this.features.length === 0) {
+    if (!this.workingFeatures || this.workingFeatures.length === 0) {
       this.canvasService.requestRenderAll();
       return;
     }
@@ -565,11 +659,11 @@ export class FeatureTool implements Extension {
     const finalScale = scale;
 
     // Group features by groupId
-    const groups: { [key: string]: { feature: DielineFeature; index: number }[] } =
+    const groups: { [key: string]: { feature: ConstraintFeature; index: number }[] } =
       {};
-    const singles: { feature: DielineFeature; index: number }[] = [];
+    const singles: { feature: ConstraintFeature; index: number }[] = [];
 
-    this.features.forEach((f, i) => {
+    this.workingFeatures.forEach((f: ConstraintFeature, i: number) => {
       if (f.groupId) {
         if (!groups[f.groupId]) groups[f.groupId] = [];
         groups[f.groupId].push({ feature: f, index: i });
@@ -580,10 +674,9 @@ export class FeatureTool implements Extension {
 
     // Helper to create marker shape
     const createMarkerShape = (
-      feature: DielineFeature,
+      feature: ConstraintFeature,
       pos: { x: number; y: number },
     ) => {
-      // Features are in the same unit as geometry.unit
       const featureScale = scale;
 
       const visualWidth = (feature.width || 10) * featureScale;
@@ -628,6 +721,42 @@ export class FeatureTool implements Extension {
       if (feature.rotation) {
         shape.rotate(feature.rotation);
       }
+      
+      // Handle Indicator for Bridge
+      if (feature.bridge && feature.bridge.type === "vertical") {
+         // Create a visual indicator for the bridge
+         // A dashed rectangle extending upwards
+         const bridgeIndicator = new Rect({
+           width: visualWidth,
+           height: 100 * featureScale, // Arbitrary long length to show direction
+           fill: "transparent",
+           stroke: "#888",
+           strokeWidth: 1,
+           strokeDashArray: [2, 2],
+           originX: "center",
+           originY: "bottom", // Anchor at bottom so it extends up
+           left: pos.x,
+           top: pos.y - visualHeight / 2, // Start from top of feature
+           opacity: 0.5,
+           selectable: false,
+           evented: false
+         });
+         
+         // We need to return a group containing both shape and indicator
+         // But createMarkerShape is expected to return one object.
+         // If we return a Group, Fabric handles it.
+         // But the caller might wrap this in another Group if it's part of a feature group.
+         // Fabric supports nested groups.
+         
+         const group = new Group([bridgeIndicator, shape], {
+            originX: "center",
+            originY: "center",
+            left: pos.x,
+            top: pos.y
+         });
+         return group;
+      }
+      
       return shape;
     };
 
@@ -653,27 +782,6 @@ export class FeatureTool implements Extension {
         data: { type: "feature-marker", index, isGroup: false },
       });
 
-      // Auto-hide logic
-      marker.set("opacity", 0);
-      marker.on("mouseover", () => {
-        marker.set("opacity", 1);
-        canvas.requestRenderAll();
-      });
-      marker.on("mouseout", () => {
-        if (canvas.getActiveObject() !== marker) {
-          marker.set("opacity", 0);
-          canvas.requestRenderAll();
-        }
-      });
-      marker.on("selected", () => {
-        marker.set("opacity", 1);
-        canvas.requestRenderAll();
-      });
-      marker.on("deselected", () => {
-        marker.set("opacity", 0);
-        canvas.requestRenderAll();
-      });
-
       canvas.add(marker);
       canvas.bringObjectToFront(marker);
     });
@@ -718,27 +826,6 @@ export class FeatureTool implements Extension {
         },
       });
 
-      // Auto-hide logic for group
-      groupObj.set("opacity", 0);
-      groupObj.on("mouseover", () => {
-        groupObj.set("opacity", 1);
-        canvas.requestRenderAll();
-      });
-      groupObj.on("mouseout", () => {
-        if (canvas.getActiveObject() !== groupObj) {
-          groupObj.set("opacity", 0);
-          canvas.requestRenderAll();
-        }
-      });
-      groupObj.on("selected", () => {
-        groupObj.set("opacity", 1);
-        canvas.requestRenderAll();
-      });
-      groupObj.on("deselected", () => {
-        groupObj.set("opacity", 0);
-        canvas.requestRenderAll();
-      });
-
       canvas.add(groupObj);
       canvas.bringObjectToFront(groupObj);
     });
@@ -756,16 +843,16 @@ export class FeatureTool implements Extension {
 
     markers.forEach((marker: any) => {
       // Find associated feature
-      let feature: DielineFeature | undefined;
+      let feature: ConstraintFeature | undefined;
       if (marker.data?.isGroup) {
         const indices = marker.data?.indices as number[];
         if (indices && indices.length > 0) {
-          feature = this.features[indices[0]];
+          feature = this.workingFeatures[indices[0]];
         }
       } else {
         const index = marker.data?.index;
         if (index !== undefined) {
-          feature = this.features[index];
+          feature = this.workingFeatures[index];
         }
       }