@pooder/kit 4.2.0 → 4.3.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pooder/kit
 
+## 4.3.1
+
+### Patch Changes
+
+- bugfix
+
+## 4.3.0
+
+### Minor Changes
+
+- bridge and constraints
+
 ## 4.2.0
 
 ### Minor Changes

package/dist/index.d.mts

@@ -53,13 +53,12 @@ interface DielineFeature {
     height?: number;
     radius?: number;
     rotation?: number;
-    placement?: "edge" | "internal";
+    renderBehavior?: "edge" | "surface";
     color?: string;
     strokeDash?: number[];
     skipCut?: boolean;
-    constraints?: {
-        type: string;
-        params?: any;
+    bridge?: {
+        type: "vertical";
     };
 }
 
@@ -147,6 +146,14 @@ declare class FilmTool implements Extension {
     private updateFilm;
 }
 
+interface ConstraintFeature extends DielineFeature {
+    constraints?: Array<{
+        type: string;
+        params?: any;
+        validateOnly?: boolean;
+    }>;
+}
+
 declare class FeatureTool implements Extension {
     id: string;
     metadata: {
@@ -162,7 +169,7 @@ declare class FeatureTool implements Extension {
     private handleDielineChange;
     private currentGeometry;
     constructor(options?: Partial<{
-        features: DielineFeature[];
+        features: ConstraintFeature[];
     }>);
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;

package/dist/index.d.ts

@@ -53,13 +53,12 @@ interface DielineFeature {
     height?: number;
     radius?: number;
     rotation?: number;
-    placement?: "edge" | "internal";
+    renderBehavior?: "edge" | "surface";
     color?: string;
     strokeDash?: number[];
     skipCut?: boolean;
-    constraints?: {
-        type: string;
-        params?: any;
+    bridge?: {
+        type: "vertical";
     };
 }
 
@@ -147,6 +146,14 @@ declare class FilmTool implements Extension {
     private updateFilm;
 }
 
+interface ConstraintFeature extends DielineFeature {
+    constraints?: Array<{
+        type: string;
+        params?: any;
+        validateOnly?: boolean;
+    }>;
+}
+
 declare class FeatureTool implements Extension {
     id: string;
     metadata: {
@@ -162,7 +169,7 @@ declare class FeatureTool implements Extension {
     private handleDielineChange;
     private currentGeometry;
     constructor(options?: Partial<{
-        features: DielineFeature[];
+        features: ConstraintFeature[];
     }>);
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;

package/dist/index.js

@@ -823,7 +823,7 @@ function getPerimeterShape(options) {
   const { features } = options;
   if (features && features.length > 0) {
     const edgeFeatures = features.filter(
-      (f) => !f.placement || f.placement === "edge"
+      (f) => !f.renderBehavior || f.renderBehavior === "edge"
     );
     const adds = [];
     const subtracts = [];
@@ -831,10 +831,74 @@ function getPerimeterShape(options) {
       const pos = resolveFeaturePosition(f, options);
       const center = new import_paper2.default.Point(pos.x, pos.y);
       const item = createFeatureItem(f, center);
-      if (f.operation === "add") {
-        adds.push(item);
+      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) {
+          const centerX = itemBounds.center.x;
+          const ray = new import_paper2.default.Path.Line({
+            from: [centerX, bridgeBottom],
+            to: [centerX, bridgeTop - 10],
+            // Extend slightly past top to ensure intersection
+            insert: false
+          });
+          const intersections = mainShape.getIntersections(ray);
+          let targetY = bridgeTop;
+          let found = false;
+          if (intersections && intersections.length > 0) {
+            const validHits = intersections.filter((i) => i.point.y < bridgeBottom - 0.1);
+            if (validHits.length > 0) {
+              validHits.sort((a, b) => b.point.y - a.point.y);
+              targetY = validHits[0].point.y;
+              found = true;
+            }
+          }
+          ray.remove();
+          const overlap = 2;
+          const rectBottom = bridgeBottom;
+          let rectTop = found ? targetY + overlap : bridgeTop;
+          if (!found) {
+            if (mainBounds.bottom < bridgeBottom) {
+              targetY = mainBounds.bottom;
+              rectTop = targetY - overlap;
+            }
+          }
+          if (rectTop < rectBottom) {
+            const bridgeRect = new import_paper2.default.Path.Rectangle({
+              from: [itemBounds.left, rectTop],
+              to: [itemBounds.right, rectBottom],
+              insert: false
+            });
+            const unitedItem = item.unite(bridgeRect);
+            item.remove();
+            bridgeRect.remove();
+            if (f.operation === "add") {
+              adds.push(unitedItem);
+            } else {
+              subtracts.push(unitedItem);
+            }
+          } else {
+            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);
+        }
       }
     });
     if (adds.length > 0) {
@@ -867,10 +931,12 @@ function getPerimeterShape(options) {
   return mainShape;
 }
 function applySurfaceFeatures(shape, features, options) {
-  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;
-  for (const f of internalFeatures) {
+  for (const f of surfaceFeatures) {
     const pos = resolveFeaturePosition(f, options);
     const center = new import_paper2.default.Point(pos.x, pos.y);
     const item = createFeatureItem(f, center);
@@ -927,9 +993,17 @@ function generateBleedZonePath(originalOptions, offsetOptions, offset) {
   ensurePaper(paperWidth, paperHeight);
   import_paper2.default.project.activeLayer.removeChildren();
   const pOriginal = getPerimeterShape(originalOptions);
-  const shapeOriginal = applySurfaceFeatures(pOriginal, originalOptions.features, originalOptions);
+  const shapeOriginal = applySurfaceFeatures(
+    pOriginal,
+    originalOptions.features,
+    originalOptions
+  );
   const pOffset = getPerimeterShape(offsetOptions);
-  const shapeOffset = applySurfaceFeatures(pOffset, offsetOptions.features, offsetOptions);
+  const shapeOffset = applySurfaceFeatures(
+    pOffset,
+    offsetOptions.features,
+    offsetOptions
+  );
   let bleedZone;
   if (offset > 0) {
     bleedZone = shapeOffset.subtract(shapeOriginal);
@@ -942,13 +1016,29 @@ function generateBleedZonePath(originalOptions, offsetOptions, offset) {
   bleedZone.remove();
   return pathData;
 }
+function getLowestPointOnDieline(options) {
+  ensurePaper(options.width * 2, options.height * 2);
+  import_paper2.default.project.activeLayer.removeChildren();
+  const shape = createBaseShape(options);
+  const bounds = shape.bounds;
+  const result = {
+    x: bounds.center.x,
+    y: bounds.bottom
+  };
+  shape.remove();
+  return result;
+}
 function getNearestPointOnDieline(point, options) {
   ensurePaper(options.width * 2, options.height * 2);
   import_paper2.default.project.activeLayer.removeChildren();
   const shape = createBaseShape(options);
   const p = new import_paper2.default.Point(point.x, point.y);
-  const nearest = shape.getNearestPoint(p);
-  const result = { x: nearest.x, y: nearest.y };
+  const location = shape.getNearestLocation(p);
+  const result = {
+    x: location.point.x,
+    y: location.point.y,
+    normal: location.normal ? { x: location.normal.x, y: location.normal.y } : void 0
+  };
   shape.remove();
   return result;
 }
@@ -1341,7 +1431,19 @@ var DielineTool = class {
           title: "Detect Edge from Image",
           handler: async (imageUrl, options) => {
             try {
-              const pathData = await ImageTracer.trace(imageUrl, options);
+              const loadImage = (url) => {
+                return new Promise((resolve, reject) => {
+                  const img2 = new Image();
+                  img2.crossOrigin = "Anonymous";
+                  img2.onload = () => resolve(img2);
+                  img2.onerror = (e) => reject(e);
+                  img2.src = url;
+                });
+              };
+              const [img, pathData] = await Promise.all([
+                loadImage(imageUrl),
+                ImageTracer.trace(imageUrl, options)
+              ]);
               const bounds = getPathBounds(pathData);
               const currentMax = Math.max(s.width, s.height);
               const scale = currentMax / Math.max(bounds.width, bounds.height);
@@ -1350,7 +1452,10 @@ var DielineTool = class {
               return {
                 pathData,
                 width: newWidth,
-                height: newHeight
+                height: newHeight,
+                rawBounds: bounds,
+                imageWidth: img.width,
+                imageHeight: img.height
               };
             } catch (e) {
               console.error("Edge detection failed", e);
@@ -1898,22 +2003,60 @@ var ConstraintRegistry = class {
   static register(type, handler) {
     this.handlers.set(type, handler);
   }
-  static apply(x, y, feature, context) {
-    if (!feature.constraints || !feature.constraints.type) {
+  static apply(x, y, feature, context, constraints) {
+    const list = constraints || feature.constraints;
+    if (!list || list.length === 0) {
       return { x, y };
     }
-    const handler = this.handlers.get(feature.constraints.type);
-    if (handler) {
-      return handler(x, y, feature, context);
+    let currentX = x;
+    let currentY = y;
+    for (const constraint of list) {
+      const handler = this.handlers.get(constraint.type);
+      if (handler) {
+        const result = handler(currentX, currentY, feature, context, constraint.params || {});
+        currentX = result.x;
+        currentY = result.y;
+      }
     }
-    return { x, y };
+    return { x: currentX, y: currentY };
   }
 };
 ConstraintRegistry.handlers = /* @__PURE__ */ new Map();
-var edgeConstraint = (x, y, feature, context) => {
-  var _a;
+var pathConstraint = (x, y, feature, context, params) => {
+  const { dielineWidth, dielineHeight, geometry } = context;
+  if (!geometry) return { x, y };
+  const minX = geometry.x - geometry.width / 2;
+  const minY = geometry.y - geometry.height / 2;
+  const absX = minX + x * geometry.width;
+  const absY = minY + y * geometry.height;
+  const nearest = getNearestPointOnDieline(
+    { x: absX, y: absY },
+    geometry
+  );
+  let finalX = nearest.x;
+  let finalY = nearest.y;
+  const hasOffsetParams = params.minOffset !== void 0 || params.maxOffset !== void 0;
+  if (hasOffsetParams && nearest.normal) {
+    const dx = absX - nearest.x;
+    const dy = absY - nearest.y;
+    const nx2 = nearest.normal.x;
+    const ny2 = nearest.normal.y;
+    const dist = dx * nx2 + dy * ny2;
+    const scale = dielineWidth > 0 ? geometry.width / dielineWidth : 1;
+    const rawMin = params.minOffset !== void 0 ? params.minOffset : 0;
+    const rawMax = params.maxOffset !== void 0 ? params.maxOffset : 0;
+    const minOffset = rawMin * scale;
+    const maxOffset = rawMax * scale;
+    const clampedDist = Math.max(minOffset, Math.min(dist, maxOffset));
+    finalX = nearest.x + nx2 * clampedDist;
+    finalY = nearest.y + ny2 * clampedDist;
+  }
+  const nx = geometry.width > 0 ? (finalX - minX) / geometry.width : 0.5;
+  const ny = geometry.height > 0 ? (finalY - minY) / geometry.height : 0.5;
+  return { x: nx, y: ny };
+};
+var edgeConstraint = (x, y, feature, context, params) => {
   const { dielineWidth, dielineHeight } = context;
-  const params = ((_a = feature.constraints) == null ? void 0 : _a.params) || {};
   const allowedEdges = params.allowedEdges || [
     "top",
     "bottom",
@@ -1974,10 +2117,8 @@ var edgeConstraint = (x, y, feature, context) => {
   }
   return { x: newX, y: newY };
 };
-var internalConstraint = (x, y, feature, context) => {
-  var _a;
+var internalConstraint = (x, y, feature, context, params) => {
   const { dielineWidth, dielineHeight } = context;
-  const params = ((_a = feature.constraints) == null ? void 0 : _a.params) || {};
   const margin = params.margin || 0;
   const fw = feature.width || 0;
   const fh = feature.height || 0;
@@ -1989,10 +2130,8 @@ var internalConstraint = (x, y, feature, context) => {
   const clampedY = minY > maxY ? 0.5 : Math.max(minY, Math.min(y, maxY));
   return { x: clampedX, y: clampedY };
 };
-var tangentBottomConstraint = (x, y, feature, context) => {
-  var _a;
+var tangentBottomConstraint = (x, y, feature, context, params) => {
   const { dielineWidth, dielineHeight } = context;
-  const params = ((_a = feature.constraints) == null ? void 0 : _a.params) || {};
   const gap = params.gap || 0;
   const confineX = params.confineX !== false;
   const extentY = feature.shape === "circle" ? feature.radius || 0 : (feature.height || 0) / 2;
@@ -2006,18 +2145,38 @@ var tangentBottomConstraint = (x, y, feature, context) => {
   }
   return { x: newX, y: newY };
 };
+var lowestTangentConstraint = (x, y, feature, context, params) => {
+  const { dielineWidth, dielineHeight, geometry } = context;
+  if (!geometry) return { x, y };
+  const lowest = getLowestPointOnDieline(geometry);
+  const minY = geometry.y - geometry.height / 2;
+  const normY = (lowest.y - minY) / geometry.height;
+  const gap = params.gap || 0;
+  const confineX = params.confineX !== false;
+  const extentY = feature.shape === "circle" ? feature.radius || 0 : (feature.height || 0) / 2;
+  const newY = normY + (extentY + gap) / dielineHeight;
+  let newX = x;
+  if (confineX) {
+    const extentX = feature.shape === "circle" ? feature.radius || 0 : (feature.width || 0) / 2;
+    const minX = extentX / dielineWidth;
+    const maxX = 1 - extentX / dielineWidth;
+    newX = minX > maxX ? 0.5 : Math.max(minX, Math.min(newX, maxX));
+  }
+  return { x: newX, y: newY };
+};
+ConstraintRegistry.register("path", pathConstraint);
 ConstraintRegistry.register("edge", edgeConstraint);
 ConstraintRegistry.register("internal", internalConstraint);
 ConstraintRegistry.register("tangent-bottom", tangentBottomConstraint);
+ConstraintRegistry.register("lowest-tangent", lowestTangentConstraint);
 
 // src/featureComplete.ts
 function validateFeaturesStrict(features, context) {
-  var _a;
   const eps = 1e-6;
   const issues = [];
   for (const f of features) {
-    if (!((_a = f.constraints) == null ? void 0 : _a.type)) continue;
-    const constrained = ConstraintRegistry.apply(f.x, f.y, f, context);
+    if (!f.constraints || f.constraints.length === 0) continue;
+    const constrained = ConstraintRegistry.apply(f.x, f.y, f, context, f.constraints);
     if (Math.abs(constrained.x - f.x) > eps || Math.abs(constrained.y - f.y) > eps) {
       issues.push({
         featureId: f.id,
@@ -2283,14 +2442,16 @@ var FeatureTool = class {
     const newFeature = {
       id: Date.now().toString(),
       operation: type,
-      placement: "edge",
       shape: "rect",
       x: 0.5,
       y: 0,
       // Top edge
       width: 10,
       height: 10,
-      rotation: 0
+      rotation: 0,
+      renderBehavior: "edge",
+      // Default constraint: path (snap to edge)
+      constraints: [{ type: "path" }]
     };
     this.setWorkingFeatures([...this.workingFeatures || [], newFeature]);
     this.redraw();
@@ -2306,22 +2467,24 @@ var FeatureTool = class {
       groupId,
       operation: "add",
       shape: "circle",
-      placement: "edge",
       x: 0.5,
       y: 0,
       radius: 20,
-      rotation: 0
+      rotation: 0,
+      renderBehavior: "edge",
+      constraints: [{ type: "path" }]
     };
     const hole = {
       id: `${timestamp}-hole`,
       groupId,
       operation: "subtract",
       shape: "circle",
-      placement: "edge",
       x: 0.5,
       y: 0,
       radius: 15,
-      rotation: 0
+      rotation: 0,
+      renderBehavior: "edge",
+      constraints: [{ type: "path" }]
     };
     this.setWorkingFeatures([...this.workingFeatures || [], lug, hole]);
     this.redraw();
@@ -2460,50 +2623,32 @@ var FeatureTool = class {
     this.canvasService.requestRenderAll();
   }
   constrainPosition(p, geometry, limit, feature) {
-    if (feature && feature.constraints) {
-      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;
-      const scale2 = geometry.scale || 1;
-      const dielineWidth = geometry.width / scale2;
-      const dielineHeight = geometry.height / scale2;
-      const constrained = ConstraintRegistry.apply(nx, ny, feature, {
-        dielineWidth,
-        dielineHeight
-      });
-      return {
-        x: minX + constrained.x * geometry.width,
-        y: minY + constrained.y * geometry.height
-      };
-    }
-    if (feature && feature.placement === "internal") {
-      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))
-      };
+    var _a;
+    if (!feature) {
+      return { x: p.x, y: p.y };
     }
-    const nearest = getNearestPointOnDieline(
-      { x: p.x, y: p.y },
+    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;
+    const scale = geometry.scale || 1;
+    const dielineWidth = geometry.width / scale;
+    const dielineHeight = geometry.height / scale;
+    const activeConstraints = (_a = feature.constraints) == null ? void 0 : _a.filter((c) => !c.validateOnly);
+    const constrained = ConstraintRegistry.apply(
+      nx,
+      ny,
+      feature,
       {
-        ...geometry,
-        features: []
-      }
+        dielineWidth,
+        dielineHeight,
+        geometry
+      },
+      activeConstraints
     );
-    const dx = p.x - nearest.x;
-    const dy = p.y - nearest.y;
-    const dist = Math.sqrt(dx * dx + dy * dy);
-    if (dist <= limit) {
-      return { x: p.x, y: p.y };
-    }
-    const scale = limit / dist;
     return {
-      x: nearest.x + dx * scale,
-      y: nearest.y + dy * scale
+      x: minX + constrained.x * geometry.width,
+      y: minY + constrained.y * geometry.height
     };
   }
   syncFeatureFromCanvas(target) {
@@ -2594,6 +2739,33 @@ var FeatureTool = class {
       if (feature.rotation) {
         shape.rotate(feature.rotation);
       }
+      if (feature.bridge && feature.bridge.type === "vertical") {
+        const bridgeIndicator = new import_fabric4.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
+        });
+        const group = new import_fabric4.Group([bridgeIndicator, shape], {
+          originX: "center",
+          originY: "center",
+          left: pos.x,
+          top: pos.y
+        });
+        return group;
+      }
       return shape;
     };
     singles.forEach(({ feature, index }) => {