@pooder/kit 5.4.0 → 6.0.0

package/.test-dist/src/extensions/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneLayoutService = void 0;
+__exportStar(require("./background"), exports);
+__exportStar(require("./image"), exports);
+__exportStar(require("./size"), exports);
+__exportStar(require("./dieline"), exports);
+__exportStar(require("./feature"), exports);
+__exportStar(require("./film"), exports);
+__exportStar(require("./mirror"), exports);
+__exportStar(require("./ruler"), exports);
+__exportStar(require("./white-ink"), exports);
+var sceneLayout_1 = require("./sceneLayout");
+Object.defineProperty(exports, "SceneLayoutService", { enumerable: true, get: function () { return sceneLayout_1.SceneLayoutService; } });

package/.test-dist/src/extensions/maskOps.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMask = createMask;
+exports.inferMaskMode = inferMaskMode;
+exports.analyzeAlpha = analyzeAlpha;
+exports.circularMorphology = circularMorphology;
+exports.fillHoles = fillHoles;
+exports.countForeground = countForeground;
+exports.isMaskConnected8 = isMaskConnected8;
+exports.findMinimalConnectRadius = findMinimalConnectRadius;
+exports.polygonSignedArea = polygonSignedArea;
+function createMask(imageData, options) {
+    const { width, height, data } = imageData;
+    const { threshold, padding, paddedWidth, paddedHeight, maskMode = "auto", whiteThreshold = 240, alphaOpaqueCutoff = 250, } = options;
+    const resolvedMode = maskMode === "auto" ? inferMaskMode(imageData, alphaOpaqueCutoff) : maskMode;
+    const mask = new Uint8Array(paddedWidth * paddedHeight);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const r = data[srcIdx];
+            const g = data[srcIdx + 1];
+            const b = data[srcIdx + 2];
+            const a = data[srcIdx + 3];
+            const destIdx = (y + padding) * paddedWidth + (x + padding);
+            if (resolvedMode === "alpha") {
+                if (a > threshold)
+                    mask[destIdx] = 1;
+            }
+            else {
+                if (a > threshold &&
+                    !(r > whiteThreshold && g > whiteThreshold && b > whiteThreshold)) {
+                    mask[destIdx] = 1;
+                }
+            }
+        }
+    }
+    return mask;
+}
+function inferMaskMode(imageData, alphaOpaqueCutoff) {
+    const analysis = analyzeAlpha(imageData, alphaOpaqueCutoff);
+    if (analysis.minAlpha === 255)
+        return "whitebg";
+    if (analysis.veryTransparentRatio >= 0.0005)
+        return "alpha";
+    if (analysis.belowOpaqueRatio >= 0.01)
+        return "alpha";
+    return "whitebg";
+}
+function analyzeAlpha(imageData, alphaOpaqueCutoff) {
+    const { data } = imageData;
+    const total = data.length / 4;
+    let belowOpaque = 0;
+    let veryTransparent = 0;
+    let minAlpha = 255;
+    for (let i = 3; i < data.length; i += 4) {
+        const a = data[i];
+        if (a < minAlpha)
+            minAlpha = a;
+        if (a < alphaOpaqueCutoff)
+            belowOpaque++;
+        if (a < 32)
+            veryTransparent++;
+    }
+    return {
+        total,
+        minAlpha,
+        belowOpaqueRatio: belowOpaque / total,
+        veryTransparentRatio: veryTransparent / total,
+    };
+}
+function circularMorphology(mask, width, height, radius, op) {
+    const r = Math.max(0, Math.floor(radius));
+    if (r <= 0) {
+        return mask.slice();
+    }
+    // Disk kernel dilation (Euclidean metric).
+    const dilateDisk = (m, radiusPx) => {
+        const horizontalDist = new Int32Array(width * height);
+        for (let y = 0; y < height; y++) {
+            let lastSolid = -radiusPx * 2;
+            for (let x = 0; x < width; x++) {
+                if (m[y * width + x])
+                    lastSolid = x;
+                horizontalDist[y * width + x] = x - lastSolid;
+            }
+            lastSolid = width + radiusPx * 2;
+            for (let x = width - 1; x >= 0; x--) {
+                if (m[y * width + x])
+                    lastSolid = x;
+                horizontalDist[y * width + x] = Math.min(horizontalDist[y * width + x], lastSolid - x);
+            }
+        }
+        const result = new Uint8Array(width * height);
+        const r2 = radiusPx * radiusPx;
+        for (let x = 0; x < width; x++) {
+            for (let y = 0; y < height; y++) {
+                let found = false;
+                const minY = Math.max(0, y - radiusPx);
+                const maxY = Math.min(height - 1, y + radiusPx);
+                for (let dy = minY; dy <= maxY; dy++) {
+                    const dY = dy - y;
+                    const hDist = horizontalDist[dy * width + x];
+                    if (hDist * hDist + dY * dY <= r2) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (found)
+                    result[y * width + x] = 1;
+            }
+        }
+        return result;
+    };
+    // Diamond kernel erosion (L1 metric), implemented as radius iterations of
+    // 4-neighbor erosion. This is intentionally different from dilation kernel.
+    const erodeDiamond = (m, radiusPx) => {
+        if (radiusPx <= 0)
+            return m.slice();
+        let current = m;
+        for (let step = 0; step < radiusPx; step++) {
+            const next = new Uint8Array(width * height);
+            for (let y = 1; y < height - 1; y++) {
+                const row = y * width;
+                for (let x = 1; x < width - 1; x++) {
+                    const idx = row + x;
+                    if (current[idx] &&
+                        current[idx - 1] &&
+                        current[idx + 1] &&
+                        current[idx - width] &&
+                        current[idx + width]) {
+                        next[idx] = 1;
+                    }
+                }
+            }
+            current = next;
+        }
+        return current;
+    };
+    // Restore thin bridges removed by erosion: if a removed pixel links two
+    // opposite neighbors in the source mask, bring it back.
+    const restoreBridgePixels = (source, eroded) => {
+        const restored = eroded.slice();
+        for (let y = 1; y < height - 1; y++) {
+            const row = y * width;
+            for (let x = 1; x < width - 1; x++) {
+                const idx = row + x;
+                if (!source[idx] || restored[idx])
+                    continue;
+                const up = source[idx - width] === 1;
+                const down = source[idx + width] === 1;
+                const left = source[idx - 1] === 1;
+                const right = source[idx + 1] === 1;
+                const upLeft = source[idx - width - 1] === 1;
+                const upRight = source[idx - width + 1] === 1;
+                const downLeft = source[idx + width - 1] === 1;
+                const downRight = source[idx + width + 1] === 1;
+                const keepsBridge = (left && right) ||
+                    (up && down) ||
+                    (upLeft && downRight) ||
+                    (upRight && downLeft);
+                if (keepsBridge) {
+                    restored[idx] = 1;
+                }
+            }
+        }
+        return restored;
+    };
+    const erodePreservingBridges = (m, radiusPx) => {
+        const eroded = erodeDiamond(m, radiusPx);
+        return restoreBridgePixels(m, eroded);
+    };
+    switch (op) {
+        case "dilate":
+            return dilateDisk(mask, r);
+        case "erode":
+            return erodePreservingBridges(mask, r);
+        case "closing": {
+            const erodeRadius = Math.max(1, Math.floor(r * 0.65));
+            return erodePreservingBridges(dilateDisk(mask, r), erodeRadius);
+        }
+        case "opening":
+            return dilateDisk(erodePreservingBridges(mask, r), r);
+        default:
+            return mask;
+    }
+}
+function fillHoles(mask, width, height) {
+    const background = new Uint8Array(width * height);
+    const queue = [];
+    for (let x = 0; x < width; x++) {
+        if (mask[x] === 0) {
+            background[x] = 1;
+            queue.push(x);
+        }
+        const lastRowIdx = (height - 1) * width + x;
+        if (mask[lastRowIdx] === 0) {
+            background[lastRowIdx] = 1;
+            queue.push(lastRowIdx);
+        }
+    }
+    for (let y = 1; y < height - 1; y++) {
+        const leftIdx = y * width;
+        const rightIdx = y * width + (width - 1);
+        if (mask[leftIdx] === 0) {
+            background[leftIdx] = 1;
+            queue.push(leftIdx);
+        }
+        if (mask[rightIdx] === 0) {
+            background[rightIdx] = 1;
+            queue.push(rightIdx);
+        }
+    }
+    let head = 0;
+    while (head < queue.length) {
+        const idx = queue[head++];
+        const x = idx % width;
+        const y = (idx - x) / width;
+        const up = y > 0 ? idx - width : -1;
+        const down = y < height - 1 ? idx + width : -1;
+        const left = x > 0 ? idx - 1 : -1;
+        const right = x < width - 1 ? idx + 1 : -1;
+        if (up >= 0 && mask[up] === 0 && background[up] === 0) {
+            background[up] = 1;
+            queue.push(up);
+        }
+        if (down >= 0 && mask[down] === 0 && background[down] === 0) {
+            background[down] = 1;
+            queue.push(down);
+        }
+        if (left >= 0 && mask[left] === 0 && background[left] === 0) {
+            background[left] = 1;
+            queue.push(left);
+        }
+        if (right >= 0 && mask[right] === 0 && background[right] === 0) {
+            background[right] = 1;
+            queue.push(right);
+        }
+    }
+    const filledMask = new Uint8Array(width * height);
+    for (let i = 0; i < width * height; i++) {
+        filledMask[i] = background[i] === 0 ? 1 : 0;
+    }
+    return filledMask;
+}
+function countForeground(mask) {
+    let c = 0;
+    for (let i = 0; i < mask.length; i++)
+        c += mask[i] ? 1 : 0;
+    return c;
+}
+function isMaskConnected8(mask, width, height) {
+    const total = countForeground(mask);
+    if (total === 0)
+        return true;
+    let start = -1;
+    for (let i = 0; i < mask.length; i++) {
+        if (mask[i]) {
+            start = i;
+            break;
+        }
+    }
+    if (start === -1)
+        return true;
+    const visited = new Uint8Array(mask.length);
+    const queue = [start];
+    visited[start] = 1;
+    let seen = 1;
+    let head = 0;
+    while (head < queue.length) {
+        const idx = queue[head++];
+        const x = idx % width;
+        const y = (idx - x) / width;
+        for (let dy = -1; dy <= 1; dy++) {
+            const ny = y + dy;
+            if (ny < 0 || ny >= height)
+                continue;
+            for (let dx = -1; dx <= 1; dx++) {
+                if (dx === 0 && dy === 0)
+                    continue;
+                const nx = x + dx;
+                if (nx < 0 || nx >= width)
+                    continue;
+                const nidx = ny * width + nx;
+                if (mask[nidx] && !visited[nidx]) {
+                    visited[nidx] = 1;
+                    queue.push(nidx);
+                    seen++;
+                }
+            }
+        }
+    }
+    return seen === total;
+}
+function findMinimalConnectRadius(mask, width, height, maxRadius) {
+    if (maxRadius <= 0)
+        return 0;
+    if (isMaskConnected8(mask, width, height))
+        return 0;
+    let low = 0;
+    let high = 1;
+    while (high <= maxRadius) {
+        const closed = circularMorphology(mask, width, height, high, "closing");
+        if (isMaskConnected8(closed, width, height))
+            break;
+        high *= 2;
+    }
+    if (high > maxRadius)
+        high = maxRadius;
+    if (!isMaskConnected8(circularMorphology(mask, width, height, high, "closing"), width, height)) {
+        return high;
+    }
+    while (low + 1 < high) {
+        const mid = Math.floor((low + high) / 2);
+        const closed = circularMorphology(mask, width, height, mid, "closing");
+        if (isMaskConnected8(closed, width, height)) {
+            high = mid;
+        }
+        else {
+            low = mid;
+        }
+    }
+    return high;
+}
+function polygonSignedArea(points) {
+    if (points.length < 3)
+        return 0;
+    let sum = 0;
+    for (let i = 0; i < points.length; i++) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        sum += a.x * b.y - b.x * a.y;
+    }
+    return sum / 2;
+}

package/.test-dist/src/extensions/mirror.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MirrorTool = void 0;
+const core_1 = require("@pooder/core");
+class MirrorTool {
+    constructor(options) {
+        this.id = "pooder.kit.mirror";
+        this.metadata = {
+            name: "MirrorTool",
+        };
+        this.enabled = false;
+        if (options) {
+            Object.assign(this, options);
+        }
+    }
+    toJSON() {
+        return {
+            enabled: this.enabled,
+        };
+    }
+    loadFromJSON(json) {
+        this.enabled = json.enabled;
+    }
+    activate(context) {
+        this.canvasService = context.services.get("CanvasService");
+        if (!this.canvasService) {
+            console.warn("CanvasService not found for MirrorTool");
+            return;
+        }
+        const configService = context.services.get("ConfigurationService");
+        if (configService) {
+            // Load initial config
+            this.enabled = configService.get("mirror.enabled", this.enabled);
+            // Listen for changes
+            configService.onAnyChange((e) => {
+                if (e.key === "mirror.enabled") {
+                    this.applyMirror(e.value);
+                }
+            });
+        }
+        // Initialize with current state (if enabled was persisted)
+        if (this.enabled) {
+            this.applyMirror(true);
+        }
+    }
+    deactivate(context) {
+        this.applyMirror(false);
+        this.canvasService = undefined;
+    }
+    contribute() {
+        return {
+            [core_1.ContributionPointIds.CONFIGURATIONS]: [
+                {
+                    id: "mirror.enabled",
+                    type: "boolean",
+                    label: "Enable Mirror",
+                    default: false,
+                },
+            ],
+            [core_1.ContributionPointIds.COMMANDS]: [
+                {
+                    command: "setMirror",
+                    title: "Set Mirror",
+                    handler: (enabled) => {
+                        this.applyMirror(enabled);
+                        return true;
+                    },
+                },
+            ],
+        };
+    }
+    applyMirror(enabled) {
+        if (!this.canvasService)
+            return;
+        const canvas = this.canvasService.canvas;
+        if (!canvas)
+            return;
+        const width = canvas.width || 800;
+        // Fabric.js v6+ uses viewportTransform property
+        let vpt = canvas.viewportTransform || [1, 0, 0, 1, 0, 0];
+        // Create a copy to avoid mutating the reference directly before setting
+        vpt = [...vpt];
+        // If we are enabling and currently not flipped (scaleX > 0)
+        // Or disabling and currently flipped (scaleX < 0)
+        const isFlipped = vpt[0] < 0;
+        if (enabled && !isFlipped) {
+            // Flip scale X
+            vpt[0] = -vpt[0]; // Flip scale
+            vpt[4] = width - vpt[4]; // Adjust pan X
+            canvas.setViewportTransform(vpt);
+            canvas.requestRenderAll();
+            this.enabled = true;
+        }
+        else if (!enabled && isFlipped) {
+            // Restore
+            vpt[0] = -vpt[0]; // Unflip scale
+            vpt[4] = width - vpt[4]; // Restore pan X
+            canvas.setViewportTransform(vpt);
+            canvas.requestRenderAll();
+            this.enabled = false;
+        }
+    }
+}
+exports.MirrorTool = MirrorTool;