@pooder/kit 3.5.0 → 4.1.0

package/src/constraints.ts

@@ -0,0 +1,158 @@
+import { DielineFeature } from "./geometry";
+
+export interface ConstraintContext {
+  dielineWidth: number;
+  dielineHeight: number;
+}
+
+export type ConstraintHandler = (
+  x: number,
+  y: number,
+  feature: DielineFeature,
+  context: ConstraintContext
+) => { x: number; y: number };
+
+export class ConstraintRegistry {
+  private static handlers = new Map<string, ConstraintHandler>();
+
+  static register(type: string, handler: ConstraintHandler) {
+    this.handlers.set(type, handler);
+  }
+
+  static apply(
+    x: number,
+    y: number,
+    feature: DielineFeature,
+    context: ConstraintContext
+  ): { x: number; y: number } {
+    if (!feature.constraints || !feature.constraints.type) {
+      return { x, y };
+    }
+
+    const handler = this.handlers.get(feature.constraints.type);
+    if (handler) {
+      return handler(x, y, feature, context);
+    }
+
+    return { x, y };
+  }
+}
+
+// --- Built-in Strategies ---
+
+/**
+ * Edge Constraint Strategy
+ * Snaps the feature to the nearest allowed edge.
+ * Params:
+ * - allowedEdges: ('top' | 'bottom' | 'left' | 'right')[] (default: all)
+ * - confine: boolean (default: false) - if true, keeps feature within edge length
+ * - offset: number (default: 0) - physical offset from edge (positive = inwards usually, but here 0 is edge)
+ *   For simplicity, let's say offset is additive to the edge position.
+ *   Top: 0 + offset
+ *   Bottom: 1 - offset
+ *   Left: 0 + offset
+ *   Right: 1 - offset
+ */
+const edgeConstraint: ConstraintHandler = (x, y, feature, context) => {
+  const { dielineWidth, dielineHeight } = context;
+  const params = feature.constraints?.params || {};
+  const allowedEdges = params.allowedEdges || [
+    "top",
+    "bottom",
+    "left",
+    "right",
+  ];
+  const confine = params.confine || false;
+  const offset = params.offset || 0;
+
+  // Calculate physical distances to allowed edges
+  const distances: { edge: string; dist: number }[] = [];
+
+  if (allowedEdges.includes("top"))
+    distances.push({ edge: "top", dist: y * dielineHeight });
+  if (allowedEdges.includes("bottom"))
+    distances.push({ edge: "bottom", dist: (1 - y) * dielineHeight });
+  if (allowedEdges.includes("left"))
+    distances.push({ edge: "left", dist: x * dielineWidth });
+  if (allowedEdges.includes("right"))
+    distances.push({ edge: "right", dist: (1 - x) * dielineWidth });
+
+  if (distances.length === 0) return { x, y };
+
+  // Find nearest
+  distances.sort((a, b) => a.dist - b.dist);
+  const nearest = distances[0].edge;
+
+  let newX = x;
+  let newY = y;
+  const fw = feature.width || 0;
+  const fh = feature.height || 0;
+
+  // Snap to edge
+  switch (nearest) {
+    case "top":
+      newY = 0 + offset / dielineHeight;
+      if (confine) {
+        const minX = (fw / 2) / dielineWidth;
+        const maxX = 1 - minX;
+        newX = Math.max(minX, Math.min(newX, maxX));
+      }
+      break;
+    case "bottom":
+      newY = 1 - offset / dielineHeight;
+      if (confine) {
+        const minX = (fw / 2) / dielineWidth;
+        const maxX = 1 - minX;
+        newX = Math.max(minX, Math.min(newX, maxX));
+      }
+      break;
+    case "left":
+      newX = 0 + offset / dielineWidth;
+      if (confine) {
+        const minY = (fh / 2) / dielineHeight;
+        const maxY = 1 - minY;
+        newY = Math.max(minY, Math.min(newY, maxY));
+      }
+      break;
+    case "right":
+      newX = 1 - offset / dielineWidth;
+      if (confine) {
+        const minY = (fh / 2) / dielineHeight;
+        const maxY = 1 - minY;
+        newY = Math.max(minY, Math.min(newY, maxY));
+      }
+      break;
+  }
+
+  return { x: newX, y: newY };
+};
+
+/**
+ * Internal Constraint Strategy
+ * Keeps the feature strictly inside the dieline bounds with optional margin.
+ * Params:
+ * - margin: number (default: 0) - physical margin
+ */
+const internalConstraint: ConstraintHandler = (x, y, feature, context) => {
+  const { dielineWidth, dielineHeight } = context;
+  const params = feature.constraints?.params || {};
+  const margin = params.margin || 0;
+  const fw = feature.width || 0;
+  const fh = feature.height || 0;
+
+  const minX = (margin + fw / 2) / dielineWidth;
+  const maxX = 1 - (margin + fw / 2) / dielineWidth;
+  
+  const minY = (margin + fh / 2) / dielineHeight;
+  const maxY = 1 - (margin + fh / 2) / dielineHeight;
+
+  // Handle case where feature is larger than container
+  const clampedX = minX > maxX ? 0.5 : Math.max(minX, Math.min(x, maxX));
+  const clampedY = minY > maxY ? 0.5 : Math.max(minY, Math.min(y, maxY));
+
+  return { x: clampedX, y: clampedY };
+};
+
+// Register built-ins
+ConstraintRegistry.register("edge", edgeConstraint);
+ConstraintRegistry.register("internal", internalConstraint);

package/src/coordinate.ts

@@ -1,106 +1,106 @@
-export interface Point {
-  x: number;
-  y: number;
-}
-
-export interface Size {
-  width: number;
-  height: number;
-}
-
-export type Unit = "px" | "mm" | "cm" | "in";
-
-export interface Layout {
-  scale: number;
-  offsetX: number;
-  offsetY: number;
-  width: number;
-  height: number;
-}
-
-export class Coordinate {
-  /**
-   * Calculate layout to fit content within container while preserving aspect ratio.
-   */
-  static calculateLayout(
-    container: Size,
-    content: Size,
-    padding: number = 0,
-  ): Layout {
-    const availableWidth = Math.max(0, container.width - padding * 2);
-    const availableHeight = Math.max(0, container.height - padding * 2);
-
-    if (content.width === 0 || content.height === 0) {
-      return { scale: 1, offsetX: 0, offsetY: 0, width: 0, height: 0 };
-    }
-
-    const scaleX = availableWidth / content.width;
-    const scaleY = availableHeight / content.height;
-    const scale = Math.min(scaleX, scaleY);
-
-    const width = content.width * scale;
-    const height = content.height * scale;
-
-    const offsetX = (container.width - width) / 2;
-    const offsetY = (container.height - height) / 2;
-
-    return { scale, offsetX, offsetY, width, height };
-  }
-
-  /**
-   * Convert an absolute value to a normalized value (0-1).
-   * @param value Absolute value (e.g., pixels)
-   * @param total Total dimension size (e.g., canvas width)
-   */
-  static toNormalized(value: number, total: number): number {
-    return total === 0 ? 0 : value / total;
-  }
-
-  /**
-   * Convert a normalized value (0-1) to an absolute value.
-   * @param normalized Normalized value (0-1)
-   * @param total Total dimension size (e.g., canvas width)
-   */
-  static toAbsolute(normalized: number, total: number): number {
-    return normalized * total;
-  }
-
-  /**
-   * Normalize a point's coordinates.
-   */
-  static normalizePoint(point: Point, size: Size): Point {
-    return {
-      x: this.toNormalized(point.x, size.width),
-      y: this.toNormalized(point.y, size.height),
-    };
-  }
-
-  /**
-   * Denormalize a point's coordinates to absolute pixels.
-   */
-  static denormalizePoint(point: Point, size: Size): Point {
-    return {
-      x: this.toAbsolute(point.x, size.width),
-      y: this.toAbsolute(point.y, size.height),
-    };
-  }
-
-  static convertUnit(value: number, from: Unit, to: Unit): number {
-    if (from === to) return value;
-    
-    // Base unit: mm
-    const toMM: Record<Unit, number> = {
-      px: 0.264583, // 1px = 0.264583mm (96 DPI)
-      mm: 1,
-      cm: 10,
-      in: 25.4
-    };
-
-    const mmValue = value * (from === 'px' ? toMM.px : toMM[from] || 1);
-    
-    if (to === 'px') {
-        return mmValue / toMM.px;
-    }
-    return mmValue / (toMM[to] || 1);
-  }
-}
+export interface Point {
+  x: number;
+  y: number;
+}
+
+export interface Size {
+  width: number;
+  height: number;
+}
+
+export type Unit = "px" | "mm" | "cm" | "in";
+
+export interface Layout {
+  scale: number;
+  offsetX: number;
+  offsetY: number;
+  width: number;
+  height: number;
+}
+
+export class Coordinate {
+  /**
+   * Calculate layout to fit content within container while preserving aspect ratio.
+   */
+  static calculateLayout(
+    container: Size,
+    content: Size,
+    padding: number = 0,
+  ): Layout {
+    const availableWidth = Math.max(0, container.width - padding * 2);
+    const availableHeight = Math.max(0, container.height - padding * 2);
+
+    if (content.width === 0 || content.height === 0) {
+      return { scale: 1, offsetX: 0, offsetY: 0, width: 0, height: 0 };
+    }
+
+    const scaleX = availableWidth / content.width;
+    const scaleY = availableHeight / content.height;
+    const scale = Math.min(scaleX, scaleY);
+
+    const width = content.width * scale;
+    const height = content.height * scale;
+
+    const offsetX = (container.width - width) / 2;
+    const offsetY = (container.height - height) / 2;
+
+    return { scale, offsetX, offsetY, width, height };
+  }
+
+  /**
+   * Convert an absolute value to a normalized value (0-1).
+   * @param value Absolute value (e.g., pixels)
+   * @param total Total dimension size (e.g., canvas width)
+   */
+  static toNormalized(value: number, total: number): number {
+    return total === 0 ? 0 : value / total;
+  }
+
+  /**
+   * Convert a normalized value (0-1) to an absolute value.
+   * @param normalized Normalized value (0-1)
+   * @param total Total dimension size (e.g., canvas width)
+   */
+  static toAbsolute(normalized: number, total: number): number {
+    return normalized * total;
+  }
+
+  /**
+   * Normalize a point's coordinates.
+   */
+  static normalizePoint(point: Point, size: Size): Point {
+    return {
+      x: this.toNormalized(point.x, size.width),
+      y: this.toNormalized(point.y, size.height),
+    };
+  }
+
+  /**
+   * Denormalize a point's coordinates to absolute pixels.
+   */
+  static denormalizePoint(point: Point, size: Size): Point {
+    return {
+      x: this.toAbsolute(point.x, size.width),
+      y: this.toAbsolute(point.y, size.height),
+    };
+  }
+
+  static convertUnit(value: number, from: Unit, to: Unit): number {
+    if (from === to) return value;
+    
+    // Base unit: mm
+    const toMM: Record<Unit, number> = {
+      px: 0.264583, // 1px = 0.264583mm (96 DPI)
+      mm: 1,
+      cm: 10,
+      in: 25.4
+    };
+
+    const mmValue = value * (from === 'px' ? toMM.px : toMM[from] || 1);
+    
+    if (to === 'px') {
+        return mmValue / toMM.px;
+    }
+    return mmValue / (toMM[to] || 1);
+  }
+}

package/src/dieline.ts

@@ -14,8 +14,9 @@ import {
   generateMaskPath,
   generateBleedZonePath,
   getPathBounds,
-  EdgeFeature,
+  DielineFeature,
 } from "./geometry";
+import { ConstraintRegistry } from "./constraints";
 
 export interface DielineGeometry {
   shape: "rect" | "circle" | "ellipse" | "custom";
@@ -52,7 +53,7 @@ export interface DielineState {
   insideColor: string;
   outsideColor: string;
   showBleedLines: boolean;
-  features: EdgeFeature[];
+  features: DielineFeature[];
   pathData?: string;
 }
 
@@ -332,6 +333,40 @@ export class DielineTool implements Extension {
         },
       ] as ConfigurationContribution[],
       [ContributionPointIds.COMMANDS]: [
+        {
+          command: "updateFeaturePosition",
+          title: "Update Feature Position",
+          handler: (groupId: string, x: number, y: number) => {
+            const configService = this.context?.services.get<any>(
+              "ConfigurationService",
+            );
+            if (!configService) return;
+
+            const features = configService.get("dieline.features") || [];
+            const dielineWidth = configService.get("dieline.width") || 500;
+            const dielineHeight = configService.get("dieline.height") || 500;
+
+            let changed = false;
+            const newFeatures = features.map((f: any) => {
+              if (f.groupId === groupId) {
+                const constrained = ConstraintRegistry.apply(x, y, f, {
+                  dielineWidth,
+                  dielineHeight,
+                });
+
+                if (f.x !== constrained.x || f.y !== constrained.y) {
+                  changed = true;
+                  return { ...f, x: constrained.x, y: constrained.y };
+                }
+              }
+              return f;
+            });
+
+            if (changed) {
+              configService.update("dieline.features", newFeatures);
+            }
+          },
+        },
         {
           command: "getGeometry",
           title: "Get Geometry",
@@ -512,12 +547,8 @@ export class DielineTool implements Extension {
       };
     });
 
-    const originalFeatures = absoluteFeatures.filter(
-      (f) => !f.target || f.target === "original" || f.target === "both",
-    );
-    const offsetFeatures = absoluteFeatures.filter(
-      (f) => f.target === "offset" || f.target === "both",
-    );
+    // Split features into Cut (Physical) and Visual (All)
+    const cutFeatures = absoluteFeatures.filter((f) => !f.skipCut);
 
     // 1. Draw Mask (Outside)
     const cutW = Math.max(0, visualWidth + visualOffset * 2);
@@ -525,10 +556,6 @@ export class DielineTool implements Extension {
     const cutR =
       visualRadius === 0 ? 0 : Math.max(0, visualRadius + visualOffset);
 
-    // If no bleed offset, mask should match the original dieline (including its features)
-    // If bleed offset exists (positive or negative), mask matches bleed line (which only includes offset features)
-    const maskFeatures = visualOffset !== 0 ? offsetFeatures : originalFeatures;
-
     // Use Paper.js to generate the complex mask path
     const maskPathData = generateMaskPath({
       canvasWidth: canvasW,
@@ -539,7 +566,7 @@ export class DielineTool implements Extension {
       radius: cutR,
       x: cx,
       y: cy,
-      features: maskFeatures,
+      features: cutFeatures,
       pathData: this.state.pathData,
     });
 
@@ -569,7 +596,7 @@ export class DielineTool implements Extension {
         radius: cutR,
         x: cx,
         y: cy,
-        features: maskFeatures, // Use same features as mask for consistency
+        features: cutFeatures, // Use same features as mask for consistency
         pathData: this.state.pathData,
         canvasWidth: canvasW,
         canvasHeight: canvasH,
@@ -596,7 +623,7 @@ export class DielineTool implements Extension {
           radius: visualRadius,
           x: cx,
           y: cy,
-          features: originalFeatures,
+          features: cutFeatures,
           pathData: this.state.pathData,
           canvasWidth: canvasW,
           canvasHeight: canvasH,
@@ -608,7 +635,7 @@ export class DielineTool implements Extension {
           radius: cutR,
           x: cx,
           y: cy,
-          features: offsetFeatures,
+          features: cutFeatures,
           pathData: this.state.pathData,
           canvasWidth: canvasW,
           canvasHeight: canvasH,
@@ -641,7 +668,7 @@ export class DielineTool implements Extension {
         radius: cutR,
         x: cx,
         y: cy,
-        features: offsetFeatures,
+        features: cutFeatures,
         pathData: this.state.pathData,
         canvasWidth: canvasW,
         canvasHeight: canvasH,
@@ -671,7 +698,7 @@ export class DielineTool implements Extension {
       radius: visualRadius,
       x: cx,
       y: cy,
-      features: originalFeatures,
+      features: absoluteFeatures,
       pathData: this.state.pathData,
       canvasWidth: canvasW,
       canvasHeight: canvasH,
@@ -798,9 +825,7 @@ export class DielineTool implements Extension {
       };
     });
 
-    const originalFeatures = absoluteFeatures.filter(
-      (f) => !f.target || f.target === "original" || f.target === "both",
-    );
+    const cutFeatures = absoluteFeatures.filter((f) => !f.skipCut);
 
     const generatedPathData = generateDielinePath({
       shape,
@@ -809,7 +834,7 @@ export class DielineTool implements Extension {
       radius: visualRadius,
       x: cx,
       y: cy,
-      features: originalFeatures,
+      features: cutFeatures,
       pathData,
       canvasWidth: canvasW,
       canvasHeight: canvasH,