@pooder/kit 6.2.0 → 6.2.1

package/dist/index.mjs

@@ -4582,6 +4582,259 @@ function readDielineState(configService, fallback) {
   };
 }
 
+// src/extensions/constraints.ts
+var ConstraintRegistry = class {
+  static register(type, handler) {
+    this.handlers.set(type, handler);
+  }
+  static apply(x, y, feature, context, constraints) {
+    const list = constraints || feature.constraints;
+    if (!list || list.length === 0) {
+      return { x, y };
+    }
+    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: currentX, y: currentY };
+  }
+};
+ConstraintRegistry.handlers = /* @__PURE__ */ new Map();
+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 allowedEdges = params.allowedEdges || [
+    "top",
+    "bottom",
+    "left",
+    "right"
+  ];
+  const confine = params.confine || false;
+  const offset = params.offset || 0;
+  const distances = [];
+  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 };
+  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;
+  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 };
+};
+var internalConstraint = (x, y, feature, context, params) => {
+  const { dielineWidth, dielineHeight } = context;
+  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;
+  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 };
+};
+var tangentBottomConstraint = (x, y, feature, context, params) => {
+  const { dielineWidth, dielineHeight } = context;
+  const gap = params.gap || 0;
+  const confineX = params.confineX !== false;
+  const extentY = feature.shape === "circle" ? feature.radius || 0 : (feature.height || 0) / 2;
+  const newY = 1 + (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 };
+};
+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/extensions/featureCoordinates.ts
+function resolveFeaturePosition2(feature, geometry) {
+  const { x, y, width, height } = geometry;
+  const left = x - width / 2;
+  const top = y - height / 2;
+  return {
+    x: left + feature.x * width,
+    y: top + feature.y * height
+  };
+}
+function normalizePointInGeometry(point, geometry) {
+  const left = geometry.x - geometry.width / 2;
+  const top = geometry.y - geometry.height / 2;
+  return {
+    x: geometry.width > 0 ? (point.x - left) / geometry.width : 0.5,
+    y: geometry.height > 0 ? (point.y - top) / geometry.height : 0.5
+  };
+}
+
+// src/extensions/featurePlacement.ts
+function scaleFeatureForRender(feature, scale, x, y) {
+  return {
+    ...feature,
+    x,
+    y,
+    width: feature.width !== void 0 ? feature.width * scale : void 0,
+    height: feature.height !== void 0 ? feature.height * scale : void 0,
+    radius: feature.radius !== void 0 ? feature.radius * scale : void 0
+  };
+}
+function resolveFeaturePlacements(features, geometry) {
+  const dielineWidth = geometry.scale > 0 ? geometry.width / geometry.scale : geometry.width;
+  const dielineHeight = geometry.scale > 0 ? geometry.height / geometry.scale : geometry.height;
+  return (features || []).map((feature) => {
+    var _a;
+    const activeConstraints = (_a = feature.constraints) == null ? void 0 : _a.filter(
+      (constraint) => !constraint.validateOnly
+    );
+    const constrained = ConstraintRegistry.apply(
+      feature.x,
+      feature.y,
+      feature,
+      {
+        dielineWidth,
+        dielineHeight,
+        geometry
+      },
+      activeConstraints
+    );
+    const center = resolveFeaturePosition2(
+      {
+        ...feature,
+        x: constrained.x,
+        y: constrained.y
+      },
+      geometry
+    );
+    return {
+      feature,
+      normalizedX: constrained.x,
+      normalizedY: constrained.y,
+      centerX: center.x,
+      centerY: center.y
+    };
+  });
+}
+function projectPlacedFeatures(placements, geometry, scale) {
+  return placements.map((placement) => {
+    const normalized = normalizePointInGeometry(
+      { x: placement.centerX, y: placement.centerY },
+      geometry
+    );
+    return scaleFeatureForRender(
+      placement.feature,
+      scale,
+      normalized.x,
+      normalized.y
+    );
+  });
+}
+
 // src/extensions/dieline/renderBuilder.ts
 var DEFAULT_IDS = {
   inside: "dieline.inside",
@@ -4591,16 +4844,6 @@ var DEFAULT_IDS = {
   clip: "dieline.clip.image",
   clipSource: "dieline.effect.clip-path"
 };
-function scaleFeatures(state, scale) {
-  return (state.features || []).map((feature) => ({
-    ...feature,
-    x: feature.x,
-    y: feature.y,
-    width: (feature.width || 0) * scale,
-    height: (feature.height || 0) * scale,
-    radius: (feature.radius || 0) * scale
-  }));
-}
 function buildDielineRenderBundle(options) {
   const ids = { ...DEFAULT_IDS, ...options.ids || {} };
   const {
@@ -4625,8 +4868,41 @@ function buildDielineRenderBundle(options) {
   const cutH = sceneLayout.cutRect.height;
   const visualOffset = (cutW - visualWidth) / 2;
   const cutR = visualRadius === 0 ? 0 : Math.max(0, visualRadius + visualOffset);
-  const absoluteFeatures = scaleFeatures(state, scale);
-  const cutFeatures = absoluteFeatures.filter((feature) => !feature.skipCut);
+  const placements = resolveFeaturePlacements(state.features || [], {
+    shape,
+    shapeStyle,
+    pathData: state.pathData,
+    customSourceWidthPx: state.customSourceWidthPx,
+    customSourceHeightPx: state.customSourceHeightPx,
+    canvasWidth,
+    canvasHeight,
+    x: cx,
+    y: cy,
+    width: visualWidth,
+    height: visualHeight,
+    radius: visualRadius,
+    scale
+  });
+  const absoluteFeatures = projectPlacedFeatures(
+    placements,
+    {
+      x: cx,
+      y: cy,
+      width: visualWidth,
+      height: visualHeight
+    },
+    scale
+  );
+  const cutFeatures = projectPlacedFeatures(
+    placements.filter((placement) => !placement.feature.skipCut),
+    {
+      x: cx,
+      y: cy,
+      width: cutW,
+      height: cutH
+    },
+    scale
+  );
   const common = {
     shape,
     shapeStyle,
@@ -5055,15 +5331,31 @@ var DielineTool = class {
     const visualRadius = radius * scale;
     const visualOffset = (cutW - sceneLayout.trimRect.width) / 2;
     const cutR = visualRadius === 0 ? 0 : Math.max(0, visualRadius + visualOffset);
-    const absoluteFeatures = (features || []).map((f) => ({
-      ...f,
-      x: f.x,
-      y: f.y,
-      width: (f.width || 0) * scale,
-      height: (f.height || 0) * scale,
-      radius: (f.radius || 0) * scale
-    }));
-    const cutFeatures = absoluteFeatures.filter((f) => !f.skipCut);
+    const placements = resolveFeaturePlacements(features || [], {
+      shape,
+      shapeStyle,
+      pathData,
+      customSourceWidthPx: this.state.customSourceWidthPx,
+      customSourceHeightPx: this.state.customSourceHeightPx,
+      canvasWidth: canvasW,
+      canvasHeight: canvasH,
+      x: cx,
+      y: cy,
+      width: sceneLayout.trimRect.width,
+      height: sceneLayout.trimRect.height,
+      radius: visualRadius,
+      scale
+    });
+    const cutFeatures = projectPlacedFeatures(
+      placements.filter((placement) => !placement.feature.skipCut),
+      {
+        x: cx,
+        y: cy,
+        width: cutW,
+        height: cutH
+      },
+      scale
+    );
     const generatedPathData = generateDielinePath({
       shape,
       width: cutW,
@@ -5189,178 +5481,6 @@ import {
 } from "@pooder/core";
 import { Pattern as Pattern3 } from "fabric";
 
-// src/extensions/constraints.ts
-var ConstraintRegistry = class {
-  static register(type, handler) {
-    this.handlers.set(type, handler);
-  }
-  static apply(x, y, feature, context, constraints) {
-    const list = constraints || feature.constraints;
-    if (!list || list.length === 0) {
-      return { x, y };
-    }
-    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: currentX, y: currentY };
-  }
-};
-ConstraintRegistry.handlers = /* @__PURE__ */ new Map();
-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 allowedEdges = params.allowedEdges || [
-    "top",
-    "bottom",
-    "left",
-    "right"
-  ];
-  const confine = params.confine || false;
-  const offset = params.offset || 0;
-  const distances = [];
-  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 };
-  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;
-  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 };
-};
-var internalConstraint = (x, y, feature, context, params) => {
-  const { dielineWidth, dielineHeight } = context;
-  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;
-  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 };
-};
-var tangentBottomConstraint = (x, y, feature, context, params) => {
-  const { dielineWidth, dielineHeight } = context;
-  const gap = params.gap || 0;
-  const confineX = params.confineX !== false;
-  const extentY = feature.shape === "circle" ? feature.radius || 0 : (feature.height || 0) / 2;
-  const newY = 1 + (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 };
-};
-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/extensions/featureComplete.ts
 function validateFeaturesStrict(features, context) {
   const eps = 1e-6;
@@ -6136,9 +6256,29 @@ var FeatureTool = class {
     }
     const groups = /* @__PURE__ */ new Map();
     const singles = [];
-    this.workingFeatures.forEach((feature, index) => {
+    const placements = resolveFeaturePlacements(
+      this.workingFeatures,
+      {
+        shape: this.currentGeometry.shape,
+        shapeStyle: this.currentGeometry.shapeStyle,
+        pathData: this.currentGeometry.pathData,
+        customSourceWidthPx: this.currentGeometry.customSourceWidthPx,
+        customSourceHeightPx: this.currentGeometry.customSourceHeightPx,
+        x: this.currentGeometry.x,
+        y: this.currentGeometry.y,
+        width: this.currentGeometry.width,
+        height: this.currentGeometry.height,
+        radius: this.currentGeometry.radius,
+        scale: this.currentGeometry.scale || 1
+      }
+    );
+    placements.forEach((placement, index) => {
+      const feature = placement.feature;
       const geometry = this.getGeometryForFeature(this.currentGeometry, feature);
-      const position = resolveFeaturePosition(feature, geometry);
+      const position = {
+        x: placement.centerX,
+        y: placement.centerY
+      };
       const scale = geometry.scale || 1;
       const marker = {
         feature,
@@ -6715,11 +6855,12 @@ var EXTENSION_LINE_LENGTH = 5;
 var MIN_ARROW_SIZE = 4;
 var THICKNESS_TO_STROKE_WIDTH_RATIO = 20;
 var DEFAULT_THICKNESS = 20;
-var DEFAULT_GAP = 45;
+var DEFAULT_GAP = 65;
 var DEFAULT_FONT_SIZE = 10;
 var DEFAULT_BACKGROUND_COLOR = "#f0f0f0";
 var DEFAULT_TEXT_COLOR = "#333333";
 var DEFAULT_LINE_COLOR = "#999999";
+var RULER_DEBUG_KEY = "ruler.debug";
 var RULER_THICKNESS_MIN = 10;
 var RULER_THICKNESS_MAX = 100;
 var RULER_GAP_MIN = 0;
@@ -6738,6 +6879,7 @@ var RulerTool = class {
     this.textColor = DEFAULT_TEXT_COLOR;
     this.lineColor = DEFAULT_LINE_COLOR;
     this.fontSize = DEFAULT_FONT_SIZE;
+    this.debugEnabled = false;
     this.renderSeq = 0;
     this.numericProps = /* @__PURE__ */ new Set(["thickness", "gap", "fontSize"]);
     this.specs = [];
@@ -6786,7 +6928,14 @@ var RulerTool = class {
       this.syncConfig(configService);
       configService.onAnyChange((e) => {
         let shouldUpdate = false;
-        if (e.key.startsWith("ruler.")) {
+        if (e.key === RULER_DEBUG_KEY) {
+          this.debugEnabled = e.value === true;
+          this.log("config:update", {
+            key: e.key,
+            raw: e.value,
+            normalized: this.debugEnabled
+          });
+        } else if (e.key.startsWith("ruler.")) {
           const prop = e.key.split(".")[1];
           if (prop && prop in this) {
             if (this.numericProps.has(prop)) {
@@ -6873,6 +7022,12 @@ var RulerTool = class {
           min: RULER_FONT_SIZE_MIN,
           max: RULER_FONT_SIZE_MAX,
           default: DEFAULT_FONT_SIZE
+        },
+        {
+          id: RULER_DEBUG_KEY,
+          type: "boolean",
+          label: "Ruler Debug Log",
+          default: false
         }
       ],
       [ContributionPointIds8.COMMANDS]: [
@@ -6909,7 +7064,11 @@ var RulerTool = class {
       ]
     };
   }
+  isDebugEnabled() {
+    return this.debugEnabled;
+  }
   log(step, payload) {
+    if (!this.isDebugEnabled()) return;
     if (payload) {
       console.debug(`[RulerTool] ${step}`, payload);
       return;
@@ -6938,6 +7097,7 @@ var RulerTool = class {
       configService.get("ruler.fontSize", this.fontSize),
       DEFAULT_FONT_SIZE
     );
+    this.debugEnabled = configService.get(RULER_DEBUG_KEY, this.debugEnabled) === true;
     this.log("config:loaded", {
       thickness: this.thickness,
       gap: this.gap,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pooder/kit",
-  "version": "6.2.0",
+  "version": "6.2.1",
   "description": "Standard plugins for Pooder editor",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/extensions/dieline/DielineTool.ts

@@ -26,6 +26,10 @@ import {
   readDielineState,
 } from "./model";
 import { buildDielineRenderBundle } from "./renderBuilder";
+import {
+  projectPlacedFeatures,
+  resolveFeaturePlacements,
+} from "../featurePlacement";
 
 export class DielineTool implements Extension {
   id = "pooder.kit.dieline";
@@ -320,15 +324,31 @@ export class DielineTool implements Extension {
     const cutR =
       visualRadius === 0 ? 0 : Math.max(0, visualRadius + visualOffset);
 
-    const absoluteFeatures = (features || []).map((f) => ({
-      ...f,
-      x: f.x,
-      y: f.y,
-      width: (f.width || 0) * scale,
-      height: (f.height || 0) * scale,
-      radius: (f.radius || 0) * scale,
-    }));
-    const cutFeatures = absoluteFeatures.filter((f) => !f.skipCut);
+    const placements = resolveFeaturePlacements(features || [], {
+      shape,
+      shapeStyle,
+      pathData,
+      customSourceWidthPx: this.state.customSourceWidthPx,
+      customSourceHeightPx: this.state.customSourceHeightPx,
+      canvasWidth: canvasW,
+      canvasHeight: canvasH,
+      x: cx,
+      y: cy,
+      width: sceneLayout.trimRect.width,
+      height: sceneLayout.trimRect.height,
+      radius: visualRadius,
+      scale,
+    });
+    const cutFeatures = projectPlacedFeatures(
+      placements.filter((placement) => !placement.feature.skipCut),
+      {
+        x: cx,
+        y: cy,
+        width: cutW,
+        height: cutH,
+      },
+      scale,
+    );
 
     const generatedPathData = generateDielinePath({
       shape,