@pooder/kit 5.3.1 → 6.0.0

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

@@ -1,203 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackgroundTool = void 0;
-const core_1 = require("@pooder/core");
-const fabric_1 = require("fabric");
-class BackgroundTool {
-    constructor(options) {
-        this.id = "pooder.kit.background";
-        this.metadata = {
-            name: "BackgroundTool",
-        };
-        this.color = "";
-        this.url = "";
-        if (options) {
-            Object.assign(this, options);
-        }
-    }
-    activate(context) {
-        this.canvasService = context.services.get("CanvasService");
-        if (!this.canvasService) {
-            console.warn("CanvasService not found for BackgroundTool");
-            return;
-        }
-        const configService = context.services.get("ConfigurationService");
-        if (configService) {
-            // Load initial config
-            this.color = configService.get("background.color", this.color);
-            this.url = configService.get("background.url", this.url);
-            // Listen for changes
-            configService.onAnyChange((e) => {
-                if (e.key.startsWith("background.")) {
-                    const prop = e.key.split(".")[1];
-                    console.log(`[BackgroundTool] Config change detected: ${e.key} -> ${e.value}, prop: ${prop}`);
-                    if (prop && prop in this) {
-                        console.log(`[BackgroundTool] Updating option ${prop} to ${e.value}`);
-                        this[prop] = e.value;
-                        this.updateBackground();
-                    }
-                    else {
-                        console.warn(`[BackgroundTool] Property ${prop} not found in options`);
-                    }
-                }
-            });
-        }
-        this.initLayer();
-        this.updateBackground();
-    }
-    deactivate(context) {
-        if (this.canvasService) {
-            const layer = this.canvasService.getLayer("background");
-            if (layer) {
-                this.canvasService.canvas.remove(layer);
-            }
-            this.canvasService = undefined;
-        }
-    }
-    contribute() {
-        return {
-            [core_1.ContributionPointIds.CONFIGURATIONS]: [
-                {
-                    id: "background.color",
-                    type: "color",
-                    label: "Background Color",
-                    default: "",
-                },
-                {
-                    id: "background.url",
-                    type: "string",
-                    label: "Image URL",
-                    default: "",
-                },
-            ],
-            [core_1.ContributionPointIds.COMMANDS]: [
-                {
-                    command: "reset",
-                    title: "Reset Background",
-                    handler: () => {
-                        this.updateBackground();
-                        return true;
-                    },
-                },
-                {
-                    command: "clear",
-                    title: "Clear Background",
-                    handler: () => {
-                        this.color = "transparent";
-                        this.url = "";
-                        this.updateBackground();
-                        return true;
-                    },
-                },
-                {
-                    command: "setBackgroundColor",
-                    title: "Set Background Color",
-                    handler: (color) => {
-                        if (this.color === color)
-                            return true;
-                        this.color = color;
-                        this.updateBackground();
-                        return true;
-                    },
-                },
-                {
-                    command: "setBackgroundImage",
-                    title: "Set Background Image",
-                    handler: (url) => {
-                        if (this.url === url)
-                            return true;
-                        this.url = url;
-                        this.updateBackground();
-                        return true;
-                    },
-                },
-            ],
-        };
-    }
-    initLayer() {
-        if (!this.canvasService)
-            return;
-        let backgroundLayer = this.canvasService.getLayer("background");
-        if (!backgroundLayer) {
-            backgroundLayer = this.canvasService.createLayer("background", {
-                width: this.canvasService.canvas.width,
-                height: this.canvasService.canvas.height,
-                selectable: false,
-                evented: false,
-            });
-            this.canvasService.canvas.sendObjectToBack(backgroundLayer);
-        }
-    }
-    async updateBackground() {
-        if (!this.canvasService)
-            return;
-        const layer = this.canvasService.getLayer("background");
-        if (!layer) {
-            console.warn("[BackgroundTool] Background layer not found");
-            return;
-        }
-        const { color, url } = this;
-        const width = this.canvasService.canvas.width || 800;
-        const height = this.canvasService.canvas.height || 600;
-        let rect = this.canvasService.getObject("background-color-rect", "background");
-        if (rect) {
-            rect.set({
-                fill: color,
-            });
-        }
-        else {
-            rect = new fabric_1.Rect({
-                width,
-                height,
-                fill: color,
-                selectable: false,
-                evented: false,
-                data: {
-                    id: "background-color-rect",
-                },
-            });
-            layer.add(rect);
-            layer.sendObjectToBack(rect);
-        }
-        let img = this.canvasService.getObject("background-image", "background");
-        try {
-            if (img) {
-                if (img.getSrc() !== url) {
-                    if (url) {
-                        await img.setSrc(url);
-                    }
-                    else {
-                        layer.remove(img);
-                    }
-                }
-            }
-            else {
-                if (url) {
-                    img = await fabric_1.FabricImage.fromURL(url, { crossOrigin: "anonymous" });
-                    img.set({
-                        originX: "left",
-                        originY: "top",
-                        left: 0,
-                        top: 0,
-                        selectable: false,
-                        evented: false,
-                        data: {
-                            id: "background-image",
-                        },
-                    });
-                    img.scaleToWidth(width);
-                    if (img.getScaledHeight() < height)
-                        img.scaleToHeight(height);
-                    layer.add(img);
-                }
-            }
-            this.canvasService.requestRenderAll();
-        }
-        catch (e) {
-            console.error("[BackgroundTool] Failed to load image", e);
-        }
-        layer.dirty = true;
-        this.canvasService.requestRenderAll();
-    }
-}
-exports.BackgroundTool = BackgroundTool;

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

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pickExitIndex = pickExitIndex;
-exports.scoreOutsideAbove = scoreOutsideAbove;
-function pickExitIndex(hits) {
-    for (let i = 0; i < hits.length; i++) {
-        const h = hits[i];
-        if (h.insideBelow && !h.insideAbove)
-            return i;
-    }
-    return -1;
-}
-function scoreOutsideAbove(samples) {
-    let score = 0;
-    for (const s of samples) {
-        if (s.outsideAbove)
-            score++;
-    }
-    return score;
-}

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);