@pooder/kit 5.4.0 → 6.0.1

package/.test-dist/src/services/ViewportSystem.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewportSystem = void 0;
+const coordinate_1 = require("../coordinate");
+class ViewportSystem {
+    constructor(containerSize = { width: 0, height: 0 }, physicalSize = { width: 0, height: 0 }, padding = 40) {
+        this._containerSize = { width: 0, height: 0 };
+        this._physicalSize = { width: 0, height: 0 };
+        this._padding = 0;
+        this._layout = {
+            scale: 1,
+            offsetX: 0,
+            offsetY: 0,
+            width: 0,
+            height: 0,
+        };
+        this._containerSize = containerSize;
+        this._physicalSize = physicalSize;
+        this._padding = padding;
+        this.updateLayout();
+    }
+    get layout() {
+        return this._layout;
+    }
+    get scale() {
+        return this._layout.scale;
+    }
+    get offset() {
+        return { x: this._layout.offsetX, y: this._layout.offsetY };
+    }
+    updateContainer(width, height) {
+        if (this._containerSize.width === width &&
+            this._containerSize.height === height)
+            return;
+        this._containerSize = { width, height };
+        this.updateLayout();
+    }
+    updatePhysical(width, height) {
+        if (this._physicalSize.width === width &&
+            this._physicalSize.height === height)
+            return;
+        this._physicalSize = { width, height };
+        this.updateLayout();
+    }
+    setPadding(padding) {
+        if (this._padding === padding)
+            return;
+        this._padding = padding;
+        this.updateLayout();
+    }
+    updateLayout() {
+        this._layout = coordinate_1.Coordinate.calculateLayout(this._containerSize, this._physicalSize, this._padding);
+    }
+    toPixel(value) {
+        return value * this._layout.scale;
+    }
+    toPhysical(value) {
+        return this._layout.scale === 0 ? 0 : value / this._layout.scale;
+    }
+    toPixelPoint(point) {
+        return {
+            x: point.x * this._layout.scale + this._layout.offsetX,
+            y: point.y * this._layout.scale + this._layout.offsetY,
+        };
+    }
+    // Convert screen coordinate (e.g. mouse event) to physical coordinate (relative to content origin)
+    toPhysicalPoint(point) {
+        if (this._layout.scale === 0)
+            return { x: 0, y: 0 };
+        return {
+            x: (point.x - this._layout.offsetX) / this._layout.scale,
+            y: (point.y - this._layout.offsetY) / this._layout.scale,
+        };
+    }
+}
+exports.ViewportSystem = ViewportSystem;

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

@@ -0,0 +1,25 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanvasService = void 0;
+var CanvasService_1 = require("./CanvasService");
+Object.defineProperty(exports, "CanvasService", { enumerable: true, get: function () { return __importDefault(CanvasService_1).default; } });
+__exportStar(require("./renderSpec"), exports);
+__exportStar(require("./visibility"), exports);
+__exportStar(require("./ViewportSystem"), exports);

package/.test-dist/src/services/renderSpec.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/.test-dist/src/services/visibility.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateVisibilityExpr = evaluateVisibilityExpr;
+function compareLayerObjectCount(actual, cmp, expected) {
+    if (cmp === ">")
+        return actual > expected;
+    if (cmp === ">=")
+        return actual >= expected;
+    if (cmp === "<")
+        return actual < expected;
+    if (cmp === "<=")
+        return actual <= expected;
+    return actual === expected;
+}
+function layerState(context, layerId) {
+    return context.layers.get(layerId) || { exists: false, objectCount: 0 };
+}
+function evaluateVisibilityExpr(expr, context) {
+    if (!expr)
+        return true;
+    if (expr.op === "const") {
+        return Boolean(expr.value);
+    }
+    if (expr.op === "activeToolIn") {
+        const activeToolId = context.activeToolId ?? null;
+        return !!activeToolId && expr.ids.includes(activeToolId);
+    }
+    if (expr.op === "sessionActive") {
+        const toolId = String(expr.toolId || "").trim();
+        if (!toolId)
+            return false;
+        return context.isSessionActive ? context.isSessionActive(toolId) : false;
+    }
+    if (expr.op === "anySessionActive") {
+        return context.hasAnyActiveSession ? context.hasAnyActiveSession() : false;
+    }
+    if (expr.op === "layerExists") {
+        return layerState(context, expr.layerId).exists === true;
+    }
+    if (expr.op === "layerObjectCount") {
+        const expected = Number(expr.value);
+        if (!Number.isFinite(expected))
+            return false;
+        const count = layerState(context, expr.layerId).objectCount;
+        return compareLayerObjectCount(count, expr.cmp, expected);
+    }
+    if (expr.op === "not") {
+        return !evaluateVisibilityExpr(expr.expr, context);
+    }
+    if (expr.op === "all") {
+        return expr.exprs.every((item) => evaluateVisibilityExpr(item, context));
+    }
+    if (expr.op === "any") {
+        return expr.exprs.some((item) => evaluateVisibilityExpr(item, context));
+    }
+    return true;
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLengthToMm = parseLengthToMm;
+exports.formatMm = formatMm;
+const coordinate_1 = require("./coordinate");
+function parseLengthToMm(input, defaultUnit) {
+    if (typeof input === "number") {
+        if (!Number.isFinite(input))
+            return 0;
+        return coordinate_1.Coordinate.convertUnit(input, defaultUnit, "mm");
+    }
+    const raw = input.trim();
+    if (!raw)
+        return 0;
+    const match = raw.match(/^([+-]?\d+(?:\.\d+)?)\s*(px|mm|cm|in)?$/i);
+    if (!match)
+        return 0;
+    const value = Number(match[1]);
+    if (!Number.isFinite(value))
+        return 0;
+    const unit = match[2]?.toLowerCase() ?? defaultUnit;
+    return coordinate_1.Coordinate.convertUnit(value, unit, "mm");
+}
+function formatMm(valueMm, displayUnit, fractionDigits = 2) {
+    if (!Number.isFinite(valueMm))
+        return "0";
+    const value = coordinate_1.Coordinate.convertUnit(valueMm, "mm", displayUnit);
+    const rounded = Number(value.toFixed(fractionDigits));
+    return rounded.toString();
+}

package/.test-dist/tests/run.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bridgeSelection_1 = require("../src/extensions/bridgeSelection");
+const wrappedOffsets_1 = require("../src/extensions/wrappedOffsets");
+const maskOps_1 = require("../src/extensions/maskOps");
+const edgeScale_1 = require("../src/extensions/edgeScale");
+const visibility_1 = require("../src/services/visibility");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function testWrappedOffsets() {
+    assert((0, wrappedOffsets_1.wrappedDistance)(100, 10, 30) === 20, "distance 10->30 should be 20");
+    assert((0, wrappedOffsets_1.wrappedDistance)(100, 90, 10) === 20, "distance 90->10 should wrap to 20");
+    const a = (0, wrappedOffsets_1.sampleWrappedOffsets)(100, 10, 30, 5);
+    assert(JSON.stringify(a) === JSON.stringify([10, 15, 20, 25, 30]), `unexpected sample: ${JSON.stringify(a)}`);
+    const b = (0, wrappedOffsets_1.sampleWrappedOffsets)(100, 90, 10, 3);
+    assert(JSON.stringify(b) === JSON.stringify([90, 0, 10]), `unexpected wrap sample: ${JSON.stringify(b)}`);
+}
+function testBridgeSelection() {
+    const idx = (0, bridgeSelection_1.pickExitIndex)([
+        { insideAbove: true, insideBelow: true },
+        { insideAbove: false, insideBelow: true },
+        { insideAbove: false, insideBelow: false },
+    ]);
+    assert(idx === 1, `expected exit index 1, got ${idx}`);
+    const none = (0, bridgeSelection_1.pickExitIndex)([{ insideAbove: true, insideBelow: true }]);
+    assert(none === -1, `expected -1, got ${none}`);
+    const score = (0, bridgeSelection_1.scoreOutsideAbove)([
+        { outsideAbove: true },
+        { outsideAbove: false },
+        { outsideAbove: true },
+    ]);
+    assert(score === 2, `expected score 2, got ${score}`);
+}
+function testMaskOps() {
+    const width = 50;
+    const height = 50;
+    const mask = new Uint8Array(width * height);
+    mask[10 * width + 10] = 1;
+    mask[10 * width + 20] = 1;
+    const r = (0, maskOps_1.findMinimalConnectRadius)(mask, width, height, 20);
+    const closed = (0, maskOps_1.circularMorphology)(mask, width, height, r, "closing");
+    assert((0, maskOps_1.isMaskConnected8)(closed, width, height), `closed mask should be connected (r=${r})`);
+    if (r > 0) {
+        const closedPrev = (0, maskOps_1.circularMorphology)(mask, width, height, r - 1, "closing");
+        assert(!(0, maskOps_1.isMaskConnected8)(closedPrev, width, height), `r should be minimal (r=${r})`);
+    }
+    const donut = new Uint8Array(9 * 9);
+    for (let y = 1; y <= 7; y++) {
+        for (let x = 1; x <= 7; x++)
+            donut[y * 9 + x] = 1;
+    }
+    for (let y = 3; y <= 5; y++) {
+        for (let x = 3; x <= 5; x++)
+            donut[y * 9 + x] = 0;
+    }
+    const filled = (0, maskOps_1.fillHoles)(donut, 9, 9);
+    assert(filled[4 * 9 + 4] === 1, "hole should be filled");
+    const imgW = 2;
+    const imgH = 1;
+    const rgba = new Uint8ClampedArray([
+        255, 255, 255, 255, 10, 10, 10, 254,
+    ]);
+    const imageData = { width: imgW, height: imgH, data: rgba };
+    const paddedWidth = imgW + 4;
+    const paddedHeight = imgH + 4;
+    const created = (0, maskOps_1.createMask)(imageData, {
+        threshold: 10,
+        padding: 2,
+        paddedWidth,
+        paddedHeight,
+        maskMode: "auto",
+        alphaOpaqueCutoff: 250,
+    });
+    assert(created[2 * paddedWidth + 2] === 0, "white pixel should be background");
+    assert(created[2 * paddedWidth + 3] === 1, "non-white pixel should be foreground");
+}
+function testEdgeScale() {
+    const currentMax = 100;
+    const baseBounds = { width: 50, height: 20 };
+    const expandedBounds = { width: 70, height: 40 };
+    const { width, height, scale } = (0, edgeScale_1.computeDetectEdgeSize)(currentMax, baseBounds, expandedBounds);
+    assert(scale === 2, `expected scale 2, got ${scale}`);
+    assert(width === 140, `expected width 140, got ${width}`);
+    assert(height === 80, `expected height 80, got ${height}`);
+}
+function testVisibilityDsl() {
+    const layers = new Map([
+        ["ruler-overlay", { exists: true, objectCount: 2 }],
+        ["feature-overlay", { exists: true, objectCount: 0 }],
+    ]);
+    const context = {
+        activeToolId: "pooder.kit.image",
+        isSessionActive: (toolId) => toolId === "pooder.kit.feature",
+        hasAnyActiveSession: () => true,
+        layers,
+    };
+    assert((0, visibility_1.evaluateVisibilityExpr)({ op: "const", value: true }, context) === true, "const true failed");
+    assert((0, visibility_1.evaluateVisibilityExpr)({ op: "const", value: false }, context) === false, "const false failed");
+    assert((0, visibility_1.evaluateVisibilityExpr)({ op: "activeToolIn", ids: ["pooder.kit.image"] }, context) === true, "activeToolIn true failed");
+    assert((0, visibility_1.evaluateVisibilityExpr)({ op: "activeToolIn", ids: ["pooder.kit.white-ink"] }, context) === false, "activeToolIn false failed");
+    assert((0, visibility_1.evaluateVisibilityExpr)({ op: "sessionActive", toolId: "pooder.kit.feature" }, context) === true, "sessionActive true failed");
+    assert((0, visibility_1.evaluateVisibilityExpr)({ op: "sessionActive", toolId: "pooder.kit.ruler" }, context) === false, "sessionActive false failed");
+    assert((0, visibility_1.evaluateVisibilityExpr)({ op: "anySessionActive" }, context) === true, "anySessionActive true failed");
+    assert((0, visibility_1.evaluateVisibilityExpr)({ op: "layerExists", layerId: "ruler-overlay" }, context) === true, "layerExists true failed");
+    assert((0, visibility_1.evaluateVisibilityExpr)({ op: "layerExists", layerId: "missing-layer" }, context) === false, "layerExists false failed");
+    const comparisons = [
+        { cmp: ">", value: 1, expected: true },
+        { cmp: ">=", value: 2, expected: true },
+        { cmp: "==", value: 2, expected: true },
+        { cmp: "<", value: 2, expected: false },
+        { cmp: "<=", value: 1, expected: false },
+    ];
+    comparisons.forEach((entry) => {
+        assert((0, visibility_1.evaluateVisibilityExpr)({
+            op: "layerObjectCount",
+            layerId: "ruler-overlay",
+            cmp: entry.cmp,
+            value: entry.value,
+        }, context) === entry.expected, `layerObjectCount ${entry.cmp} failed`);
+    });
+    assert((0, visibility_1.evaluateVisibilityExpr)({
+        op: "not",
+        expr: { op: "activeToolIn", ids: ["pooder.kit.white-ink"] },
+    }, context) === true, "not failed");
+    assert((0, visibility_1.evaluateVisibilityExpr)({
+        op: "all",
+        exprs: [
+            { op: "layerExists", layerId: "ruler-overlay" },
+            { op: "sessionActive", toolId: "pooder.kit.feature" },
+        ],
+    }, context) === true, "all failed");
+    assert((0, visibility_1.evaluateVisibilityExpr)({
+        op: "any",
+        exprs: [
+            { op: "layerExists", layerId: "missing-layer" },
+            { op: "activeToolIn", ids: ["pooder.kit.image"] },
+        ],
+    }, context) === true, "any failed");
+}
+function main() {
+    testWrappedOffsets();
+    testBridgeSelection();
+    testMaskOps();
+    testEdgeScale();
+    testVisibilityDsl();
+    console.log("ok");
+}
+main();

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pooder/kit
 
+## 6.0.1
+
+### Patch Changes
+
+- image control
+
+## 6.0.0
+
+### Major Changes
+
+- pass compositor
+
 ## 5.4.0
 
 ### Minor Changes