@pooder/kit 4.0.0 → 4.1.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @pooder/kit
 
+## 4.1.0
+
+### Minor Changes
+
+- Restriction strategy
+
 ## 4.0.0
 
 ### Major Changes

package/dist/index.d.mts

@@ -42,6 +42,10 @@ interface DielineFeature {
     color?: string;
     strokeDash?: number[];
     skipCut?: boolean;
+    constraints?: {
+        type: string;
+        params?: any;
+    };
 }
 
 interface DielineGeometry {

package/dist/index.d.ts

@@ -42,6 +42,10 @@ interface DielineFeature {
     color?: string;
     strokeDash?: number[];
     skipCut?: boolean;
+    constraints?: {
+        type: string;
+        params?: any;
+    };
 }
 
 interface DielineGeometry {

package/dist/index.js

@@ -940,6 +940,105 @@ function getPathBounds(pathData) {
   };
 }
 
+// src/constraints.ts
+var ConstraintRegistry = class {
+  static register(type, handler) {
+    this.handlers.set(type, handler);
+  }
+  static apply(x, y, feature, context) {
+    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 };
+  }
+};
+ConstraintRegistry.handlers = /* @__PURE__ */ new Map();
+var edgeConstraint = (x, y, feature, context) => {
+  var _a;
+  const { dielineWidth, dielineHeight } = context;
+  const params = ((_a = feature.constraints) == null ? void 0 : _a.params) || {};
+  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) => {
+  var _a;
+  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;
+  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 };
+};
+ConstraintRegistry.register("edge", edgeConstraint);
+ConstraintRegistry.register("internal", internalConstraint);
+
 // src/dieline.ts
 var DielineTool = class {
   constructor(options) {
@@ -1234,6 +1333,37 @@ var DielineTool = class {
         }
       ],
       [import_core2.ContributionPointIds.COMMANDS]: [
+        {
+          command: "updateFeaturePosition",
+          title: "Update Feature Position",
+          handler: (groupId, x, y) => {
+            var _a;
+            const configService = (_a = this.context) == null ? void 0 : _a.services.get(
+              "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) => {
+              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",
@@ -2124,6 +2254,23 @@ 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;

package/dist/index.mjs

@@ -900,6 +900,105 @@ function getPathBounds(pathData) {
   };
 }
 
+// src/constraints.ts
+var ConstraintRegistry = class {
+  static register(type, handler) {
+    this.handlers.set(type, handler);
+  }
+  static apply(x, y, feature, context) {
+    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 };
+  }
+};
+ConstraintRegistry.handlers = /* @__PURE__ */ new Map();
+var edgeConstraint = (x, y, feature, context) => {
+  var _a;
+  const { dielineWidth, dielineHeight } = context;
+  const params = ((_a = feature.constraints) == null ? void 0 : _a.params) || {};
+  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) => {
+  var _a;
+  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;
+  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 };
+};
+ConstraintRegistry.register("edge", edgeConstraint);
+ConstraintRegistry.register("internal", internalConstraint);
+
 // src/dieline.ts
 var DielineTool = class {
   constructor(options) {
@@ -1194,6 +1293,37 @@ var DielineTool = class {
         }
       ],
       [ContributionPointIds2.COMMANDS]: [
+        {
+          command: "updateFeaturePosition",
+          title: "Update Feature Position",
+          handler: (groupId, x, y) => {
+            var _a;
+            const configService = (_a = this.context) == null ? void 0 : _a.services.get(
+              "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) => {
+              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",
@@ -2088,6 +2218,23 @@ 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;

package/package.json

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