@pooder/kit 5.4.0 → 6.0.1

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

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

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneVisibilityService = void 0;
+const core_1 = require("@pooder/core");
+const CANVAS_SERVICE_ID = "CanvasService";
+const HIDDEN_DIELINE_TOOLS = new Set(["pooder.kit.image", "pooder.kit.white-ink"]);
+const HIDDEN_RULER_TOOLS = new Set(["pooder.kit.white-ink"]);
+class SceneVisibilityService {
+    constructor() {
+        this.activeToolId = null;
+        this.onToolActivated = (e) => {
+            this.activeToolId = e.id;
+            this.apply();
+        };
+        this.onObjectAdded = () => {
+            this.apply();
+        };
+    }
+    init(context) {
+        if (this.context) {
+            this.dispose(this.context);
+        }
+        const canvasService = context.get(CANVAS_SERVICE_ID);
+        if (!canvasService) {
+            throw new Error("[SceneVisibilityService] CanvasService is required.");
+        }
+        this.context = context;
+        this.canvasService = canvasService;
+        this.activeToolId = context.get(core_1.WORKBENCH_SERVICE)?.activeToolId ?? null;
+        context.eventBus.on("tool:activated", this.onToolActivated);
+        context.eventBus.on("object:added", this.onObjectAdded);
+        this.apply();
+    }
+    dispose(context) {
+        const activeContext = this.context ?? context;
+        activeContext.eventBus.off("tool:activated", this.onToolActivated);
+        activeContext.eventBus.off("object:added", this.onObjectAdded);
+        this.context = undefined;
+        this.activeToolId = null;
+        this.canvasService = undefined;
+    }
+    apply() {
+        if (!this.canvasService)
+            return;
+        const dielineLayer = this.canvasService.getLayer("dieline-overlay");
+        if (dielineLayer) {
+            const visible = !HIDDEN_DIELINE_TOOLS.has(this.activeToolId || "");
+            this.canvasService.setLayerVisibility("dieline-overlay", visible);
+        }
+        const rulerVisible = !HIDDEN_RULER_TOOLS.has(this.activeToolId || "");
+        this.canvasService.setLayerVisibility("ruler-overlay", rulerVisible);
+        this.canvasService.requestRenderAll();
+    }
+}
+exports.SceneVisibilityService = SceneVisibilityService;

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

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SizeTool = void 0;
+const core_1 = require("@pooder/core");
+const sceneLayoutModel_1 = require("./sceneLayoutModel");
+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 === "image.user" ? active?.data?.id : null;
+        const targetId = id || activeId;
+        const target = all.find((obj) => obj?.data?.layerId === "image.user" && obj?.data?.id === targetId) || all.find((obj) => obj?.data?.layerId === "image.user");
+        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;