@pooder/kit 4.1.0 → 4.3.0

package/src/geometry.ts

@@ -14,13 +14,13 @@ export interface DielineFeature {
   height?: number;
   radius?: number;
   rotation?: number;
-  placement?: "edge" | "internal";
+  // Rendering behavior: 'edge' (modifies perimeter) or 'surface' (hole/island)
+  renderBehavior?: "edge" | "surface";
   color?: string;
   strokeDash?: number[];
   skipCut?: boolean;
-  constraints?: {
-    type: string;
-    params?: any;
+  bridge?: {
+    type: "vertical";
   };
 }
 
@@ -161,9 +161,9 @@ function getPerimeterShape(options: GeometryOptions): paper.PathItem {
   const { features } = options;
 
   if (features && features.length > 0) {
-    // Filter for Edge Features (Default or explicit 'edge')
+    // Filter for Edge Features (Default is Edge, unless explicit 'surface')
     const edgeFeatures = features.filter(
-      (f) => !f.placement || f.placement === "edge",
+      (f) => !f.renderBehavior || f.renderBehavior === "edge",
     );
 
     const adds: paper.PathItem[] = [];
@@ -173,11 +173,107 @@ function getPerimeterShape(options: GeometryOptions): paper.PathItem {
       const pos = resolveFeaturePosition(f, options);
       const center = new paper.Point(pos.x, pos.y);
       const item = createFeatureItem(f, center);
-      
-      if (f.operation === "add") {
-        adds.push(item);
+
+      // Handle Bridge logic: Create a connection shape to the main body
+      if (f.bridge && f.bridge.type === "vertical") {
+        const itemBounds = item.bounds;
+        const mainBounds = mainShape.bounds;
+        const bridgeTop = mainBounds.top;
+        const bridgeBottom = itemBounds.top;
+
+        if (bridgeBottom > bridgeTop) {
+          // 1. Create a full column up to the top of the main shape
+          // Start slightly inside the feature to ensure overlap at the bottom
+          const startY = bridgeBottom + 1; 
+          const bridgeRect = new paper.Path.Rectangle({
+            from: [itemBounds.left, bridgeTop],
+            to: [itemBounds.right, startY],
+            insert: false,
+          });
+
+          // 2. Subtract the main shape from this column
+          // This leaves us with the parts of the column that are NOT inside the main shape (gaps)
+          const gaps = bridgeRect.subtract(mainShape);
+          bridgeRect.remove();
+
+          // 3. Find the gap piece that connects to our feature
+          // It should be the piece with the lowest bottom (highest Y) matching our feature top
+          let bridgePart: paper.PathItem | null = null;
+
+          // Helper to check if a part is the bottom one
+          const isBottomPart = (part: paper.PathItem) => {
+             // Check if bottom aligns with feature top (allow small tolerance)
+             return Math.abs(part.bounds.bottom - startY) < 2; 
+          };
+
+          if (gaps instanceof paper.CompoundPath) {
+             // Find the child that is at the bottom
+             const children = gaps.children;
+             let maxBottom = -Infinity;
+             let bestChild = null;
+             
+             for (const child of children) {
+                if (child.bounds.bottom > maxBottom) {
+                   maxBottom = child.bounds.bottom;
+                   bestChild = child;
+                }
+             }
+             
+             if (bestChild && isBottomPart(bestChild as paper.PathItem)) {
+                bridgePart = (bestChild as paper.PathItem).clone();
+             }
+          } else if (gaps instanceof paper.Path) {
+             if (isBottomPart(gaps)) {
+                bridgePart = gaps.clone();
+             }
+          }
+          
+          gaps.remove();
+
+          if (bridgePart) {
+              // Overlap fix:
+              // Scale the bridge up slightly from the bottom to ensure it overlaps with the main shape at the top.
+              // This prevents hairline gaps due to perfect alignment from subtract().
+              const bounds = bridgePart.bounds;
+              if (bounds.height > 0) {
+                 const overlap = 1; 
+                 const scaleY = (bounds.height + overlap) / bounds.height;
+                 // Scale around the bottom-center to keep the connection to the feature intact
+                 bridgePart.scale(1, scaleY, new paper.Point(bounds.center.x, bounds.bottom));
+              }
+
+              // Unite the bridge with the feature
+              const unitedItem = item.unite(bridgePart);
+              item.remove();
+              bridgePart.remove();
+              
+              if (f.operation === "add") {
+                adds.push(unitedItem);
+              } else {
+                subtracts.push(unitedItem);
+              }
+           } else {
+             // No bridge needed (feature touches or intersects main shape directly)
+             // or calculation failed. Fallback to original item.
+             if (f.operation === "add") {
+               adds.push(item);
+             } else {
+               subtracts.push(item);
+             }
+          }
+        } else {
+           if (f.operation === "add") {
+              adds.push(item);
+           } else {
+              subtracts.push(item);
+           }
+        }
       } else {
-        subtracts.push(item);
+        if (f.operation === "add") {
+          adds.push(item);
+        } else {
+          subtracts.push(item);
+        }
       }
     });
 
@@ -223,38 +319,40 @@ function applySurfaceFeatures(
   features: DielineFeature[],
   options: GeometryOptions,
 ): paper.PathItem {
-  const internalFeatures = features.filter((f) => f.placement === "internal");
-  
-  if (internalFeatures.length === 0) return shape;
+  const surfaceFeatures = features.filter(
+    (f) => f.renderBehavior === "surface",
+  );
+
+  if (surfaceFeatures.length === 0) return shape;
 
   let result = shape;
-  
+
   // Internal features are usually subtractive (holes)
   // But we support 'add' too (islands? maybe just unite)
-  
-  for (const f of internalFeatures) {
+
+  for (const f of surfaceFeatures) {
     const pos = resolveFeaturePosition(f, options);
     const center = new paper.Point(pos.x, pos.y);
     const item = createFeatureItem(f, center);
 
     try {
       if (f.operation === "add") {
-         const temp = result.unite(item);
-         result.remove();
-         item.remove();
-         result = temp;
+        const temp = result.unite(item);
+        result.remove();
+        item.remove();
+        result = temp;
       } else {
-         const temp = result.subtract(item);
-         result.remove();
-         item.remove();
-         result = temp;
+        const temp = result.subtract(item);
+        result.remove();
+        item.remove();
+        result = temp;
       }
     } catch (e) {
       console.error("Geometry: Failed to apply surface feature", e);
       item.remove();
     }
   }
-  
+
   return result;
 }
 
@@ -322,11 +420,19 @@ export function generateBleedZonePath(
 
   // 1. Generate Original Shape
   const pOriginal = getPerimeterShape(originalOptions);
-  const shapeOriginal = applySurfaceFeatures(pOriginal, originalOptions.features, originalOptions);
+  const shapeOriginal = applySurfaceFeatures(
+    pOriginal,
+    originalOptions.features,
+    originalOptions,
+  );
 
   // 2. Generate Offset Shape
   const pOffset = getPerimeterShape(offsetOptions);
-  const shapeOffset = applySurfaceFeatures(pOffset, offsetOptions.features, offsetOptions);
+  const shapeOffset = applySurfaceFeatures(
+    pOffset,
+    offsetOptions.features,
+    offsetOptions,
+  );
 
   // 3. Calculate Difference
   let bleedZone: paper.PathItem;
@@ -345,6 +451,27 @@ export function generateBleedZonePath(
   return pathData;
 }
 
+/**
+ * Finds the lowest point (Max Y) on the Dieline geometry (Base Shape ONLY).
+ */
+export function getLowestPointOnDieline(
+  options: GeometryOptions,
+): { x: number; y: number } {
+  ensurePaper(options.width * 2, options.height * 2);
+  paper.project.activeLayer.removeChildren();
+
+  const shape = createBaseShape(options);
+  const bounds = shape.bounds;
+
+  const result = {
+    x: bounds.center.x,
+    y: bounds.bottom,
+  };
+  shape.remove();
+
+  return result;
+}
+
 /**
  * Finds the nearest point on the Dieline geometry (Base Shape ONLY) for a given target point.
  * Used for constraining feature movement.
@@ -352,7 +479,7 @@ export function generateBleedZonePath(
 export function getNearestPointOnDieline(
   point: { x: number; y: number },
   options: GeometryOptions,
-): { x: number; y: number } {
+): { x: number; y: number; normal?: { x: number; y: number } } {
   ensurePaper(options.width * 2, options.height * 2);
   paper.project.activeLayer.removeChildren();
 
@@ -361,9 +488,13 @@ export function getNearestPointOnDieline(
   const shape = createBaseShape(options);
 
   const p = new paper.Point(point.x, point.y);
-  const nearest = shape.getNearestPoint(p);
+  const location = shape.getNearestLocation(p);
 
-  const result = { x: nearest.x, y: nearest.y };
+  const result = {
+    x: location.point.x,
+    y: location.point.y,
+    normal: location.normal ? { x: location.normal.x, y: location.normal.y } : undefined
+  };
   shape.remove();
 
   return result;