@pooder/kit 5.3.0 → 5.4.0

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

@@ -1,237 +0,0 @@
-"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

@@ -1,74 +0,0 @@
-"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;