@pooder/kit 6.0.1 → 6.1.1

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

@@ -1,202 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeMmValue = sanitizeMmValue;
-exports.normalizeUnit = normalizeUnit;
-exports.normalizeConstraintMode = normalizeConstraintMode;
-exports.normalizeCutMode = normalizeCutMode;
-exports.toMm = toMm;
-exports.fromMm = fromMm;
-exports.resolvePaddingPx = resolvePaddingPx;
-exports.readSizeState = readSizeState;
-exports.computeSceneLayout = computeSceneLayout;
-exports.buildSceneGeometry = buildSceneGeometry;
-const coordinate_1 = require("../coordinate");
-const units_1 = require("../units");
-const dielineShape_1 = require("./dielineShape");
-const DEFAULT_SIZE_STATE = {
-    unit: "mm",
-    actualWidthMm: 500,
-    actualHeightMm: 500,
-    constraintMode: "free",
-    aspectRatio: 1,
-    cutMode: "trim",
-    cutMarginMm: 0,
-    viewPadding: 140,
-    minMm: 10,
-    maxMm: 2000,
-    stepMm: 0.1,
-};
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-}
-function roundToStep(value, step) {
-    if (!Number.isFinite(step) || step <= 0)
-        return value;
-    return Math.round(value / step) * step;
-}
-function sanitizeMmValue(valueMm, limits) {
-    if (!Number.isFinite(valueMm))
-        return limits.minMm;
-    const rounded = roundToStep(valueMm, limits.stepMm);
-    return clamp(rounded, limits.minMm, limits.maxMm);
-}
-function normalizeUnit(value) {
-    if (value === "cm" || value === "in")
-        return value;
-    return "mm";
-}
-function normalizeConstraintMode(value) {
-    if (value === "lockAspect" || value === "equal")
-        return value;
-    return "free";
-}
-function normalizeCutMode(value) {
-    if (value === "outset" || value === "inset")
-        return value;
-    return "trim";
-}
-function toMm(value, fromUnit) {
-    return coordinate_1.Coordinate.convertUnit(value, fromUnit, "mm");
-}
-function fromMm(valueMm, toUnit) {
-    return coordinate_1.Coordinate.convertUnit(valueMm, "mm", toUnit);
-}
-function resolvePaddingPx(raw, containerWidth, containerHeight) {
-    if (typeof raw === "number")
-        return Math.max(0, raw);
-    if (typeof raw === "string") {
-        if (raw.endsWith("%")) {
-            const percent = parseFloat(raw) / 100;
-            if (!Number.isFinite(percent))
-                return 0;
-            return Math.max(0, Math.min(containerWidth, containerHeight) * percent);
-        }
-        const fixed = parseFloat(raw);
-        return Number.isFinite(fixed) ? Math.max(0, fixed) : 0;
-    }
-    return 0;
-}
-function readSizeState(configService) {
-    const unit = normalizeUnit(configService.get("size.unit", DEFAULT_SIZE_STATE.unit));
-    const minMm = Math.max(0.1, Number(configService.get("size.minMm", DEFAULT_SIZE_STATE.minMm)));
-    const maxMm = Math.max(minMm, Number(configService.get("size.maxMm", DEFAULT_SIZE_STATE.maxMm)));
-    const stepMm = Math.max(0.001, Number(configService.get("size.stepMm", DEFAULT_SIZE_STATE.stepMm)));
-    const actualWidthMm = sanitizeMmValue((0, units_1.parseLengthToMm)(configService.get("size.actualWidthMm", DEFAULT_SIZE_STATE.actualWidthMm), "mm"), { minMm, maxMm, stepMm });
-    const actualHeightMm = sanitizeMmValue((0, units_1.parseLengthToMm)(configService.get("size.actualHeightMm", DEFAULT_SIZE_STATE.actualHeightMm), "mm"), { minMm, maxMm, stepMm });
-    const aspectRaw = Number(configService.get("size.aspectRatio", DEFAULT_SIZE_STATE.aspectRatio));
-    const aspectRatio = Number.isFinite(aspectRaw) && aspectRaw > 0
-        ? aspectRaw
-        : actualWidthMm / Math.max(0.001, actualHeightMm);
-    const cutMarginMm = Math.max(0, (0, units_1.parseLengthToMm)(configService.get("size.cutMarginMm", DEFAULT_SIZE_STATE.cutMarginMm), "mm"));
-    const viewPadding = configService.get("size.viewPadding", DEFAULT_SIZE_STATE.viewPadding);
-    return {
-        unit,
-        actualWidthMm,
-        actualHeightMm,
-        constraintMode: normalizeConstraintMode(configService.get("size.constraintMode", DEFAULT_SIZE_STATE.constraintMode)),
-        aspectRatio,
-        cutMode: normalizeCutMode(configService.get("size.cutMode", DEFAULT_SIZE_STATE.cutMode)),
-        cutMarginMm,
-        viewPadding,
-        minMm,
-        maxMm,
-        stepMm,
-    };
-}
-function rectByCenter(centerX, centerY, width, height) {
-    return {
-        left: centerX - width / 2,
-        top: centerY - height / 2,
-        width,
-        height,
-        centerX,
-        centerY,
-    };
-}
-function getCutSizeMm(size) {
-    if (size.cutMode === "trim") {
-        return { widthMm: size.actualWidthMm, heightMm: size.actualHeightMm };
-    }
-    const delta = size.cutMarginMm * 2;
-    if (size.cutMode === "outset") {
-        return {
-            widthMm: size.actualWidthMm + delta,
-            heightMm: size.actualHeightMm + delta,
-        };
+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]; } };
     }
-    return {
-        widthMm: Math.max(size.minMm, size.actualWidthMm - delta),
-        heightMm: Math.max(size.minMm, size.actualHeightMm - delta),
-    };
-}
-function computeSceneLayout(canvasService, size) {
-    const canvasWidth = canvasService.canvas.width || 0;
-    const canvasHeight = canvasService.canvas.height || 0;
-    if (canvasWidth <= 0 || canvasHeight <= 0)
-        return null;
-    const { widthMm: cutWidthMm, heightMm: cutHeightMm } = getCutSizeMm(size);
-    const viewWidthMm = Math.max(size.actualWidthMm, cutWidthMm);
-    const viewHeightMm = Math.max(size.actualHeightMm, cutHeightMm);
-    if (!Number.isFinite(viewWidthMm) ||
-        !Number.isFinite(viewHeightMm) ||
-        viewWidthMm <= 0 ||
-        viewHeightMm <= 0) {
-        return null;
-    }
-    const paddingPx = resolvePaddingPx(size.viewPadding, canvasWidth, canvasHeight);
-    canvasService.viewport.updateContainer(canvasWidth, canvasHeight);
-    canvasService.viewport.setPadding(paddingPx);
-    canvasService.viewport.updatePhysical(viewWidthMm, viewHeightMm);
-    const layout = canvasService.viewport.layout;
-    if (!Number.isFinite(layout.scale) ||
-        !Number.isFinite(layout.offsetX) ||
-        !Number.isFinite(layout.offsetY) ||
-        layout.scale <= 0) {
-        return null;
-    }
-    const centerX = layout.offsetX + layout.width / 2;
-    const centerY = layout.offsetY + layout.height / 2;
-    const trimWidthPx = size.actualWidthMm * layout.scale;
-    const trimHeightPx = size.actualHeightMm * layout.scale;
-    const cutWidthPx = cutWidthMm * layout.scale;
-    const cutHeightPx = cutHeightMm * layout.scale;
-    const trimRect = rectByCenter(centerX, centerY, trimWidthPx, trimHeightPx);
-    const cutRect = rectByCenter(centerX, centerY, cutWidthPx, cutHeightPx);
-    const bleedRect = rectByCenter(centerX, centerY, Math.max(trimWidthPx, cutWidthPx), Math.max(trimHeightPx, cutHeightPx));
-    return {
-        scale: layout.scale,
-        canvasWidth,
-        canvasHeight,
-        trimRect,
-        cutRect,
-        bleedRect,
-        trimWidthMm: size.actualWidthMm,
-        trimHeightMm: size.actualHeightMm,
-        cutWidthMm,
-        cutHeightMm,
-        cutMode: size.cutMode,
-        cutMarginMm: size.cutMarginMm,
-    };
-}
-function buildSceneGeometry(configService, layout) {
-    const radiusMm = (0, units_1.parseLengthToMm)(configService.get("dieline.radius", 0), "mm");
-    const offset = (layout.cutRect.width - layout.trimRect.width) / 2;
-    const sourceWidth = Number(configService.get("dieline.customSourceWidthPx", 0));
-    const sourceHeight = Number(configService.get("dieline.customSourceHeightPx", 0));
-    const shapeStyle = (0, dielineShape_1.normalizeShapeStyle)(configService.get("dieline.shapeStyle", dielineShape_1.DEFAULT_DIELINE_SHAPE_STYLE));
-    return {
-        shape: (0, dielineShape_1.normalizeDielineShape)(configService.get("dieline.shape", dielineShape_1.DEFAULT_DIELINE_SHAPE)),
-        shapeStyle,
-        unit: "px",
-        x: layout.trimRect.centerX,
-        y: layout.trimRect.centerY,
-        width: layout.trimRect.width,
-        height: layout.trimRect.height,
-        radius: radiusMm * layout.scale,
-        offset,
-        scale: layout.scale,
-        pathData: configService.get("dieline.pathData"),
-        customSourceWidthPx: Number.isFinite(sourceWidth) && sourceWidth > 0 ? sourceWidth : undefined,
-        customSourceHeightPx: Number.isFinite(sourceHeight) && sourceHeight > 0 ? sourceHeight : undefined,
-    };
-}
+    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 });
+__exportStar(require("../shared/scene/sceneLayoutModel"), exports);

package/.test-dist/src/extensions/size/SizeTool.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SizeTool = void 0;
+const core_1 = require("@pooder/core");
+const sceneLayoutModel_1 = require("../../shared/scene/sceneLayoutModel");
+const layers_1 = require("../../shared/constants/layers");
+class SizeTool {
+    constructor() {
+        this.id = "pooder.kit.size";
+        this.metadata = {
+            name: "SizeTool",
+        };
+    }
+    activate(context) {
+        this.context = context;
+        this.canvasService = context.services.get("CanvasService");
+        const configService = context.services.get("ConfigurationService");
+        if (!configService)
+            return;
+        this.ensureDefaults(configService);
+        this.emitStateChanged();
+    }
+    deactivate(_context) {
+        this.context = undefined;
+        this.canvasService = undefined;
+    }
+    contribute() {
+        return {
+            [core_1.ContributionPointIds.TOOLS]: [
+                {
+                    id: this.id,
+                    name: "Size",
+                    interaction: "instant",
+                },
+            ],
+            [core_1.ContributionPointIds.CONFIGURATIONS]: [
+                {
+                    id: "size.unit",
+                    type: "select",
+                    label: "Display Unit",
+                    options: ["mm", "cm", "in"],
+                    default: "mm",
+                },
+                {
+                    id: "size.actualWidthMm",
+                    type: "number",
+                    label: "Actual Width (mm)",
+                    min: 10,
+                    max: 2000,
+                    step: 0.1,
+                    default: 500,
+                },
+                {
+                    id: "size.actualHeightMm",
+                    type: "number",
+                    label: "Actual Height (mm)",
+                    min: 10,
+                    max: 2000,
+                    step: 0.1,
+                    default: 500,
+                },
+                {
+                    id: "size.constraintMode",
+                    type: "select",
+                    label: "Constraint Mode",
+                    options: ["free", "lockAspect", "equal"],
+                    default: "free",
+                },
+                {
+                    id: "size.aspectRatio",
+                    type: "number",
+                    label: "Aspect Ratio",
+                    min: 0.01,
+                    max: 100,
+                    step: 0.01,
+                    default: 1,
+                },
+                {
+                    id: "size.cutMode",
+                    type: "select",
+                    label: "Cut Mode",
+                    options: ["trim", "outset", "inset"],
+                    default: "trim",
+                },
+                {
+                    id: "size.cutMarginMm",
+                    type: "number",
+                    label: "Cut Margin (mm)",
+                    min: 0,
+                    max: 100,
+                    step: 0.1,
+                    default: 0,
+                },
+                {
+                    id: "size.viewPadding",
+                    type: "select",
+                    label: "View Padding",
+                    options: [0, 10, 20, 40, 60, 100, "2%", "5%", "10%", "15%", "20%"],
+                    default: 140,
+                },
+                {
+                    id: "size.minMm",
+                    type: "number",
+                    label: "Min Size (mm)",
+                    min: 0.1,
+                    max: 2000,
+                    step: 0.1,
+                    default: 10,
+                },
+                {
+                    id: "size.maxMm",
+                    type: "number",
+                    label: "Max Size (mm)",
+                    min: 1,
+                    max: 10000,
+                    step: 1,
+                    default: 2000,
+                },
+                {
+                    id: "size.stepMm",
+                    type: "number",
+                    label: "Size Step (mm)",
+                    min: 0.001,
+                    max: 100,
+                    step: 0.001,
+                    default: 0.1,
+                },
+            ],
+            [core_1.ContributionPointIds.COMMANDS]: [
+                {
+                    command: "getSizeState",
+                    title: "Get Size State",
+                    handler: () => this.getStateForUI(),
+                },
+                {
+                    command: "updateSizeDimensions",
+                    title: "Update Size Dimensions",
+                    handler: (input = {}) => this.updateDimensions(input),
+                },
+                {
+                    command: "setSizeConstraintMode",
+                    title: "Set Size Constraint Mode",
+                    handler: (mode) => this.setConstraintMode(mode),
+                },
+                {
+                    command: "setSizeDisplayUnit",
+                    title: "Set Size Display Unit",
+                    handler: (unit) => this.setUnit(unit),
+                },
+                {
+                    command: "setSizeCut",
+                    title: "Set Size Cut",
+                    handler: (cutMode, cutMarginMm = 0) => this.setCut(cutMode, cutMarginMm),
+                },
+                {
+                    command: "getSelectedImageSize",
+                    title: "Get Selected Image Size",
+                    handler: (id) => this.getSelectedImageSize(id),
+                },
+            ],
+        };
+    }
+    getConfigService() {
+        return this.context?.services.get("ConfigurationService");
+    }
+    ensureDefaults(configService) {
+        const state = (0, sceneLayoutModel_1.readSizeState)(configService);
+        configService.update("size.unit", state.unit);
+        configService.update("size.actualWidthMm", state.actualWidthMm);
+        configService.update("size.actualHeightMm", state.actualHeightMm);
+        configService.update("size.constraintMode", state.constraintMode);
+        configService.update("size.aspectRatio", state.actualWidthMm / Math.max(0.001, state.actualHeightMm));
+        configService.update("size.cutMode", state.cutMode);
+        configService.update("size.cutMarginMm", state.cutMarginMm);
+        configService.update("size.viewPadding", state.viewPadding);
+        configService.update("size.minMm", state.minMm);
+        configService.update("size.maxMm", state.maxMm);
+        configService.update("size.stepMm", state.stepMm);
+    }
+    emitStateChanged() {
+        const state = this.getStateForUI();
+        if (!state)
+            return;
+        this.context?.eventBus.emit("size:state:changed", state);
+    }
+    getStateForUI() {
+        const configService = this.getConfigService();
+        if (!configService)
+            return null;
+        const state = (0, sceneLayoutModel_1.readSizeState)(configService);
+        return {
+            ...state,
+            actualWidth: (0, sceneLayoutModel_1.fromMm)(state.actualWidthMm, state.unit),
+            actualHeight: (0, sceneLayoutModel_1.fromMm)(state.actualHeightMm, state.unit),
+        };
+    }
+    updateDimensions(input) {
+        const configService = this.getConfigService();
+        if (!configService)
+            return null;
+        const state = (0, sceneLayoutModel_1.readSizeState)(configService);
+        const inputUnit = (0, sceneLayoutModel_1.normalizeUnit)(input.unit ?? state.unit);
+        const changed = input.changed || "both";
+        const providedWidthMm = Number.isFinite(input.width)
+            ? (0, sceneLayoutModel_1.toMm)(Number(input.width), inputUnit)
+            : undefined;
+        const providedHeightMm = Number.isFinite(input.height)
+            ? (0, sceneLayoutModel_1.toMm)(Number(input.height), inputUnit)
+            : undefined;
+        const limits = {
+            minMm: state.minMm,
+            maxMm: state.maxMm,
+            stepMm: state.stepMm,
+        };
+        let nextWidthMm = providedWidthMm !== undefined ? providedWidthMm : state.actualWidthMm;
+        let nextHeightMm = providedHeightMm !== undefined ? providedHeightMm : state.actualHeightMm;
+        if (state.constraintMode === "equal") {
+            const anchor = changed === "height"
+                ? nextHeightMm
+                : changed === "width"
+                    ? nextWidthMm
+                    : (providedWidthMm ?? providedHeightMm ?? nextWidthMm);
+            nextWidthMm = anchor;
+            nextHeightMm = anchor;
+        }
+        else if (state.constraintMode === "lockAspect") {
+            const ratio = Math.max(0.0001, state.aspectRatio);
+            if (changed === "height") {
+                nextWidthMm = nextHeightMm * ratio;
+            }
+            else {
+                nextHeightMm = nextWidthMm / ratio;
+            }
+        }
+        nextWidthMm = (0, sceneLayoutModel_1.sanitizeMmValue)(nextWidthMm, limits);
+        nextHeightMm = (0, sceneLayoutModel_1.sanitizeMmValue)(nextHeightMm, limits);
+        if (state.constraintMode === "equal") {
+            const value = Math.max(nextWidthMm, nextHeightMm);
+            nextWidthMm = value;
+            nextHeightMm = value;
+        }
+        else if (state.constraintMode === "lockAspect") {
+            const ratio = Math.max(0.0001, state.aspectRatio);
+            if (changed === "height") {
+                nextWidthMm = (0, sceneLayoutModel_1.sanitizeMmValue)(nextHeightMm * ratio, limits);
+            }
+            else {
+                nextHeightMm = (0, sceneLayoutModel_1.sanitizeMmValue)(nextWidthMm / ratio, limits);
+            }
+        }
+        configService.update("size.actualWidthMm", nextWidthMm);
+        configService.update("size.actualHeightMm", nextHeightMm);
+        configService.update("size.unit", inputUnit);
+        this.emitStateChanged();
+        return this.getStateForUI();
+    }
+    setConstraintMode(modeRaw) {
+        const configService = this.getConfigService();
+        if (!configService)
+            return null;
+        const state = (0, sceneLayoutModel_1.readSizeState)(configService);
+        const mode = (0, sceneLayoutModel_1.normalizeConstraintMode)(modeRaw);
+        configService.update("size.constraintMode", mode);
+        if (mode === "lockAspect") {
+            const ratio = state.actualWidthMm / Math.max(0.001, state.actualHeightMm);
+            configService.update("size.aspectRatio", ratio);
+        }
+        if (mode === "equal") {
+            const value = (0, sceneLayoutModel_1.sanitizeMmValue)(Math.max(state.actualWidthMm, state.actualHeightMm), {
+                minMm: state.minMm,
+                maxMm: state.maxMm,
+                stepMm: state.stepMm,
+            });
+            configService.update("size.actualWidthMm", value);
+            configService.update("size.actualHeightMm", value);
+            configService.update("size.aspectRatio", 1);
+        }
+        this.emitStateChanged();
+        return this.getStateForUI();
+    }
+    setUnit(unitRaw) {
+        const configService = this.getConfigService();
+        if (!configService)
+            return null;
+        const unit = (0, sceneLayoutModel_1.normalizeUnit)(unitRaw);
+        configService.update("size.unit", unit);
+        this.emitStateChanged();
+        return this.getStateForUI();
+    }
+    setCut(cutModeRaw, cutMarginMm = 0) {
+        const configService = this.getConfigService();
+        if (!configService)
+            return null;
+        const cutMode = (0, sceneLayoutModel_1.normalizeCutMode)(cutModeRaw);
+        const margin = Math.max(0, Number(cutMarginMm) || 0);
+        configService.update("size.cutMode", cutMode);
+        configService.update("size.cutMarginMm", margin);
+        this.emitStateChanged();
+        return this.getStateForUI();
+    }
+    getSelectedImageSize(id) {
+        const configService = this.getConfigService();
+        if (!configService || !this.canvasService)
+            return null;
+        const sizeState = (0, sceneLayoutModel_1.readSizeState)(configService);
+        const layout = (0, sceneLayoutModel_1.computeSceneLayout)(this.canvasService, sizeState);
+        if (!layout || layout.scale <= 0)
+            return null;
+        const all = this.canvasService.canvas.getObjects();
+        const active = this.canvasService.canvas.getActiveObject();
+        const activeId = active?.data?.layerId === layers_1.IMAGE_OBJECT_LAYER_ID ? active?.data?.id : null;
+        const targetId = id || activeId;
+        const target = all.find((obj) => obj?.data?.layerId === layers_1.IMAGE_OBJECT_LAYER_ID && obj?.data?.id === targetId) || all.find((obj) => obj?.data?.layerId === layers_1.IMAGE_OBJECT_LAYER_ID);
+        if (!target)
+            return null;
+        const objectWidthPx = Math.abs((target.width || 0) * (target.scaleX || 1));
+        const objectHeightPx = Math.abs((target.height || 0) * (target.scaleY || 1));
+        if (objectWidthPx <= 0 || objectHeightPx <= 0)
+            return null;
+        const widthMm = objectWidthPx / layout.scale;
+        const heightMm = objectHeightPx / layout.scale;
+        return {
+            id: target?.data?.id || null,
+            widthMm,
+            heightMm,
+            width: (0, sceneLayoutModel_1.fromMm)(widthMm, sizeState.unit),
+            height: (0, sceneLayoutModel_1.fromMm)(heightMm, sizeState.unit),
+            unit: sizeState.unit,
+        };
+    }
+}
+exports.SizeTool = SizeTool;

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

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./SizeTool"), exports);