@pooder/kit 4.3.1 → 5.0.0

package/.test-dist/src/constraints.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstraintRegistry = void 0;
+const geometry_1 = require("./geometry");
+class ConstraintRegistry {
+    static register(type, handler) {
+        this.handlers.set(type, handler);
+    }
+    static apply(x, y, feature, context, constraints // Optional override, defaults to feature.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 };
+    }
+}
+exports.ConstraintRegistry = ConstraintRegistry;
+ConstraintRegistry.handlers = new Map();
+// --- Built-in Strategies ---
+/**
+ * Path Constraint Strategy (formerly placement='edge')
+ * Snaps the feature to the nearest point on the Dieline Path.
+ */
+const pathConstraint = (x, y, feature, context, params) => {
+    // We need to denormalize, find nearest, then normalize back
+    // This is expensive but accurate.
+    const { dielineWidth, dielineHeight, geometry } = context;
+    if (!geometry)
+        return { x, y }; // Cannot snap without geometry
+    // Geometry is centered at (cx, cy)
+    // x, y are normalized (0-1) relative to bounding box
+    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;
+    // Use geometry helper
+    // Note: getNearestPointOnDieline creates a fresh paper scope each time.
+    // Optimization: geometry object passed in context could be a reusable paper path?
+    // For now, keep it simple as per existing logic.
+    const nearest = (0, geometry_1.getNearestPointOnDieline)({ x: absX, y: absY }, geometry);
+    let finalX = nearest.x;
+    let finalY = nearest.y;
+    // Only allow vertical offset if explicit offset limits are provided
+    // Otherwise, we snap strictly to the path (offset = 0)
+    const hasOffsetParams = params.minOffset !== undefined || params.maxOffset !== undefined;
+    if (hasOffsetParams && nearest.normal) {
+        // Project the cursor vector onto the normal vector
+        // This ensures the feature stays on the "normal line" of the nearest path point
+        const dx = absX - nearest.x;
+        const dy = absY - nearest.y;
+        const nx = nearest.normal.x;
+        const ny = nearest.normal.y;
+        // Dot product to get scalar projection
+        const dist = dx * nx + dy * ny;
+        // Limit the offset
+        // geometry.width is in pixels, dielineWidth is in physical units (e.g. mm)
+        // We assume dielineWidth corresponds to geometry.width
+        const scale = dielineWidth > 0 ? geometry.width / dielineWidth : 1;
+        // If one is provided but the other is not, default the other to 0.
+        // If neither is provided (shouldn't happen due to hasOffsetParams check), default to 0.
+        const rawMin = params.minOffset !== undefined ? params.minOffset : 0;
+        const rawMax = params.maxOffset !== undefined ? params.maxOffset : 0;
+        // However, if we want to allow one-sided infinity, user must explicitly provide Infinity?
+        // Wait, user requirement: "If only one is passed, the other defaults to 0."
+        // This implies:
+        // { minOffset: -5 } -> maxOffset = 0 (range: -5 to 0)
+        // { maxOffset: 5 } -> minOffset = 0 (range: 0 to 5)
+        // { minOffset: -5, maxOffset: 5 } -> (range: -5 to 5)
+        const minOffset = rawMin * scale;
+        const maxOffset = rawMax * scale;
+        const clampedDist = Math.max(minOffset, Math.min(dist, maxOffset));
+        finalX = nearest.x + nx * clampedDist;
+        finalY = nearest.y + ny * clampedDist;
+    }
+    // Re-normalize
+    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 };
+};
+/**
+ * Edge Constraint Strategy (Box Edge)
+ * Snaps the feature to the nearest allowed edge of the BOUNDING BOX.
+ */
+const 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;
+    // Calculate physical distances to allowed edges
+    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 };
+    // 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.
+ */
+const 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;
+    // 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 };
+};
+/**
+ * Bottom Tangent Strategy (stand protrusion)
+ * Forces a feature to be tangent to the dieline bottom edge from outside (below).
+ */
+const 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 };
+};
+/**
+ * Lowest Tangent Strategy (Lowest Point Lock)
+ * Finds the lowest point of the Dieline geometry and locks the feature's Y to that level.
+ * Allows horizontal movement (X).
+ */
+const lowestTangentConstraint = (x, y, feature, context, params) => {
+    const { dielineWidth, dielineHeight, geometry } = context;
+    if (!geometry)
+        return { x, y };
+    const lowest = (0, geometry_1.getLowestPointOnDieline)(geometry);
+    // Calculate normalized Y of the lowest point
+    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 };
+};
+// Register built-ins
+ConstraintRegistry.register("path", pathConstraint);
+ConstraintRegistry.register("edge", edgeConstraint);
+ConstraintRegistry.register("internal", internalConstraint);
+ConstraintRegistry.register("tangent-bottom", tangentBottomConstraint);
+ConstraintRegistry.register("lowest-tangent", lowestTangentConstraint);

package/.test-dist/src/coordinate.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Coordinate = void 0;
+class Coordinate {
+    /**
+     * Calculate layout to fit content within container while preserving aspect ratio.
+     */
+    static calculateLayout(container, content, padding = 0) {
+        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, total) {
+        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, total) {
+        return normalized * total;
+    }
+    /**
+     * Normalize a point's coordinates.
+     */
+    static normalizePoint(point, size) {
+        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, size) {
+        return {
+            x: this.toAbsolute(point.x, size.width),
+            y: this.toAbsolute(point.y, size.height),
+        };
+    }
+    static convertUnit(value, from, to) {
+        if (from === to)
+            return value;
+        // Base unit: mm
+        const toMM = {
+            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);
+    }
+}
+exports.Coordinate = Coordinate;