@pooder/kit 6.0.1 → 6.1.1

package/.test-dist/src/extensions/white-ink/commands.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWhiteInkCommands = createWhiteInkCommands;
+const WHITE_INK_PREVIEW_IMAGE_VISIBLE_KEY = "whiteInk.previewImageVisible";
+const WHITE_INK_DEFAULT_OPACITY = 0.85;
+function createWhiteInkCommands(tool) {
+    return [
+        {
+            command: "addWhiteInk",
+            id: "addWhiteInk",
+            title: "Add White Ink",
+            handler: async (url, options) => {
+                return await tool.addWhiteInkEntry(url, options);
+            },
+        },
+        {
+            command: "upsertWhiteInk",
+            id: "upsertWhiteInk",
+            title: "Upsert White Ink",
+            handler: async (url, options = {}) => {
+                return await tool.upsertWhiteInkEntry(url, options);
+            },
+        },
+        {
+            command: "getWhiteInks",
+            id: "getWhiteInks",
+            title: "Get White Inks",
+            handler: () => tool.cloneItems(tool.items),
+        },
+        {
+            command: "getWhiteInkSettings",
+            id: "getWhiteInkSettings",
+            title: "Get White Ink Settings",
+            handler: () => {
+                const first = tool.getEffectiveWhiteInkItem(tool.items);
+                const primarySource = tool.getPrimaryImageSource();
+                const sourceUrl = tool.resolveSourceUrl(first) || primarySource;
+                return {
+                    id: first?.id || null,
+                    url: sourceUrl,
+                    sourceUrl,
+                    opacity: WHITE_INK_DEFAULT_OPACITY,
+                    printWithWhiteInk: tool.printWithWhiteInk,
+                    previewImageVisible: tool.previewImageVisible,
+                };
+            },
+        },
+        {
+            command: "setWhiteInkPrintEnabled",
+            id: "setWhiteInkPrintEnabled",
+            title: "Set White Ink Preview Enabled",
+            handler: (enabled) => {
+                tool.printWithWhiteInk = !!enabled;
+                const configService = tool.context?.services.get("ConfigurationService");
+                configService?.update("whiteInk.printWithWhiteInk", tool.printWithWhiteInk);
+                tool.updateWhiteInks();
+                return { ok: true };
+            },
+        },
+        {
+            command: "setWhiteInkPreviewImageVisible",
+            id: "setWhiteInkPreviewImageVisible",
+            title: "Set White Ink Cover Visible",
+            handler: (visible) => {
+                tool.previewImageVisible = !!visible;
+                const configService = tool.context?.services.get("ConfigurationService");
+                configService?.update(WHITE_INK_PREVIEW_IMAGE_VISIBLE_KEY, tool.previewImageVisible);
+                tool.updateWhiteInks();
+                return { ok: true };
+            },
+        },
+        {
+            command: "getWorkingWhiteInks",
+            id: "getWorkingWhiteInks",
+            title: "Get Working White Inks",
+            handler: () => tool.cloneItems(tool.workingItems),
+        },
+        {
+            command: "setWorkingWhiteInk",
+            id: "setWorkingWhiteInk",
+            title: "Set Working White Ink",
+            handler: (id, updates) => {
+                tool.updateWhiteInkInWorking(id, updates);
+            },
+        },
+        {
+            command: "updateWhiteInk",
+            id: "updateWhiteInk",
+            title: "Update White Ink",
+            handler: async (id, updates, options = {}) => {
+                await tool.updateWhiteInkItem(id, updates, options);
+            },
+        },
+        {
+            command: "removeWhiteInk",
+            id: "removeWhiteInk",
+            title: "Remove White Ink",
+            handler: (id) => {
+                tool.removeWhiteInk(id);
+            },
+        },
+        {
+            command: "clearWhiteInks",
+            id: "clearWhiteInks",
+            title: "Clear White Inks",
+            handler: () => {
+                tool.clearWhiteInks();
+            },
+        },
+        {
+            command: "resetWorkingWhiteInks",
+            id: "resetWorkingWhiteInks",
+            title: "Reset Working White Inks",
+            handler: () => {
+                tool.workingItems = tool.cloneItems(tool.items);
+                tool.hasWorkingChanges = false;
+                tool.updateWhiteInks();
+            },
+        },
+        {
+            command: "completeWhiteInks",
+            id: "completeWhiteInks",
+            title: "Complete White Inks",
+            handler: async () => {
+                return await tool.completeWhiteInks();
+            },
+        },
+        {
+            command: "setWhiteInkImage",
+            id: "setWhiteInkImage",
+            title: "Set White Ink Image",
+            handler: async (url) => {
+                if (!url) {
+                    tool.clearWhiteInks();
+                    return { ok: true };
+                }
+                const targetId = tool.resolveReplaceTargetId(null);
+                const upsertResult = await tool.upsertWhiteInkEntry(url, {
+                    id: targetId || undefined,
+                    mode: targetId ? "replace" : "add",
+                    createIfMissing: true,
+                    addOptions: {},
+                });
+                return { ok: true, id: upsertResult.id };
+            },
+        },
+    ];
+}

package/.test-dist/src/extensions/white-ink/config.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWhiteInkConfigurations = createWhiteInkConfigurations;
+function createWhiteInkConfigurations() {
+    return [
+        {
+            id: "whiteInk.items",
+            type: "array",
+            label: "White Ink Images",
+            default: [],
+        },
+        {
+            id: "whiteInk.printWithWhiteInk",
+            type: "boolean",
+            label: "Preview White Ink",
+            default: true,
+        },
+        {
+            id: "whiteInk.previewImageVisible",
+            type: "boolean",
+            label: "Show Cover During White Ink Preview",
+            default: true,
+        },
+        {
+            id: "whiteInk.debug",
+            type: "boolean",
+            label: "White Ink Debug Log",
+            default: false,
+        },
+    ];
+}

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

@@ -0,0 +1,21 @@
+"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("./WhiteInkTool"), exports);
+__exportStar(require("./commands"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./model"), exports);
+__exportStar(require("./renderer"), exports);

package/.test-dist/src/extensions/white-ink/model.js

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

package/.test-dist/src/extensions/white-ink/renderer.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeWhiteInkCoverScale = void 0;
+var sourceSizeCache_1 = require("../../shared/imaging/sourceSizeCache");
+Object.defineProperty(exports, "computeWhiteInkCoverScale", { enumerable: true, get: function () { return sourceSizeCache_1.getCoverScale; } });

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneLayoutService = void 0;
+const core_1 = require("@pooder/core");
+const sceneLayoutModel_1 = require("../shared/scene/sceneLayoutModel");
+const subscriptions_1 = require("../shared/runtime/subscriptions");
+const CONFIG_WATCH_PREFIXES = ["size.", "dieline."];
+const CANVAS_SERVICE_ID = "CanvasService";
+const GET_SCENE_LAYOUT_COMMAND = "getSceneLayout";
+const GET_SCENE_GEOMETRY_COMMAND = "getSceneGeometry";
+class SceneLayoutService {
+    constructor() {
+        this.lastLayout = null;
+        this.lastGeometry = null;
+        this.subscriptions = new subscriptions_1.SubscriptionBag();
+        this.commandDisposables = [];
+        this.onCanvasResized = () => {
+            this.refresh();
+        };
+        this.onConfigChanged = (e) => {
+            if (CONFIG_WATCH_PREFIXES.some((prefix) => e.key.startsWith(prefix))) {
+                this.refresh();
+            }
+        };
+    }
+    init(context) {
+        if (this.context) {
+            this.dispose(this.context);
+        }
+        const canvasService = context.get(CANVAS_SERVICE_ID);
+        const configService = context.get(core_1.CONFIGURATION_SERVICE);
+        const commandService = context.get(core_1.COMMAND_SERVICE);
+        if (!canvasService || !configService || !commandService) {
+            throw new Error("[SceneLayoutService] CanvasService, ConfigurationService and CommandService are required.");
+        }
+        this.context = context;
+        this.canvasService = canvasService;
+        this.configService = configService;
+        this.commandDisposables.push(commandService.registerCommand(GET_SCENE_LAYOUT_COMMAND, () => this.getLayout()), commandService.registerCommand(GET_SCENE_GEOMETRY_COMMAND, () => this.getGeometry()));
+        this.subscriptions.disposeAll();
+        this.subscriptions.onConfigChange(configService, this.onConfigChanged);
+        this.subscriptions.on(context.eventBus, "canvas:resized", this.onCanvasResized);
+        this.refresh();
+    }
+    dispose(context) {
+        this.subscriptions.disposeAll();
+        this.commandDisposables.forEach((item) => item.dispose());
+        this.commandDisposables = [];
+        this.context = undefined;
+        this.canvasService = undefined;
+        this.configService = undefined;
+        this.lastLayout = null;
+        this.lastGeometry = null;
+    }
+    refresh() {
+        const layout = this.getLayout(true);
+        if (!layout) {
+            this.lastGeometry = null;
+            return;
+        }
+        this.context?.eventBus.emit("scene:layout:change", layout);
+        const geometry = this.getGeometry(true);
+        if (geometry) {
+            this.context?.eventBus.emit("scene:geometry:change", geometry);
+        }
+    }
+    getLayout(forceRefresh = false) {
+        if (!this.canvasService || !this.configService)
+            return null;
+        if (!forceRefresh && this.lastLayout)
+            return this.lastLayout;
+        const state = (0, sceneLayoutModel_1.readSizeState)(this.configService);
+        const layout = (0, sceneLayoutModel_1.computeSceneLayout)(this.canvasService, state);
+        if (!layout) {
+            this.lastLayout = null;
+            return null;
+        }
+        this.lastLayout = layout;
+        return layout;
+    }
+    getGeometry(forceRefresh = false) {
+        if (!this.configService)
+            return null;
+        const layout = this.getLayout(forceRefresh);
+        if (!layout) {
+            this.lastGeometry = null;
+            return null;
+        }
+        if (!forceRefresh && this.lastGeometry)
+            return this.lastGeometry;
+        const geometry = (0, sceneLayoutModel_1.buildSceneGeometry)(this.configService, layout);
+        this.lastGeometry = geometry;
+        return geometry;
+    }
+}
+exports.SceneLayoutService = SceneLayoutService;

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

@@ -20,6 +20,7 @@ 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("./SceneLayoutService"), exports);
 __exportStar(require("./renderSpec"), exports);
 __exportStar(require("./visibility"), exports);
 __exportStar(require("./ViewportSystem"), exports);

package/.test-dist/src/shared/constants/layers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAYER_IDS = exports.FILM_LAYER_ID = exports.RULER_LAYER_ID = exports.FEATURE_OVERLAY_LAYER_ID = exports.DIELINE_LAYER_ID = exports.WHITE_INK_OVERLAY_LAYER_ID = exports.WHITE_INK_COVER_LAYER_ID = exports.WHITE_INK_OBJECT_LAYER_ID = exports.IMAGE_OVERLAY_LAYER_ID = exports.IMAGE_OBJECT_LAYER_ID = exports.BACKGROUND_LAYER_ID = void 0;
+exports.BACKGROUND_LAYER_ID = "background";
+exports.IMAGE_OBJECT_LAYER_ID = "image.user";
+exports.IMAGE_OVERLAY_LAYER_ID = "image-overlay";
+exports.WHITE_INK_OBJECT_LAYER_ID = "white-ink.user";
+exports.WHITE_INK_COVER_LAYER_ID = "white-ink.cover";
+exports.WHITE_INK_OVERLAY_LAYER_ID = "white-ink.overlay";
+exports.DIELINE_LAYER_ID = "dieline-overlay";
+exports.FEATURE_OVERLAY_LAYER_ID = "feature-overlay";
+exports.RULER_LAYER_ID = "ruler-overlay";
+exports.FILM_LAYER_ID = "overlay";
+exports.LAYER_IDS = {
+    background: exports.BACKGROUND_LAYER_ID,
+    imageObject: exports.IMAGE_OBJECT_LAYER_ID,
+    imageOverlay: exports.IMAGE_OVERLAY_LAYER_ID,
+    whiteInkObject: exports.WHITE_INK_OBJECT_LAYER_ID,
+    whiteInkCover: exports.WHITE_INK_COVER_LAYER_ID,
+    whiteInkOverlay: exports.WHITE_INK_OVERLAY_LAYER_ID,
+    dieline: exports.DIELINE_LAYER_ID,
+    featureOverlay: exports.FEATURE_OVERLAY_LAYER_ID,
+    rulerOverlay: exports.RULER_LAYER_ID,
+    filmOverlay: exports.FILM_LAYER_ID,
+};

package/.test-dist/src/shared/imaging/sourceSizeCache.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSourceSize = normalizeSourceSize;
+exports.getCoverScale = getCoverScale;
+exports.createSourceSizeCache = createSourceSizeCache;
+function normalizeSourceSize(size) {
+    const width = Number(size.width || 0);
+    const height = Number(size.height || 0);
+    if (!Number.isFinite(width) || !Number.isFinite(height))
+        return null;
+    if (width <= 0 || height <= 0)
+        return null;
+    return { width, height };
+}
+function getCoverScale(frame, source) {
+    const frameWidth = Math.max(1, Number(frame.width || 0));
+    const frameHeight = Math.max(1, Number(frame.height || 0));
+    const sourceWidth = Math.max(1, Number(source.width || 0));
+    const sourceHeight = Math.max(1, Number(source.height || 0));
+    return Math.max(frameWidth / sourceWidth, frameHeight / sourceHeight);
+}
+function createSourceSizeCache(loadSize) {
+    const sizesBySrc = new Map();
+    const pendingBySrc = new Map();
+    const rememberSourceSize = (src, size) => {
+        const normalized = normalizeSourceSize(size);
+        if (!src || !normalized)
+            return null;
+        sizesBySrc.set(src, normalized);
+        return normalized;
+    };
+    const getSourceSize = (src) => {
+        if (!src)
+            return null;
+        const cached = sizesBySrc.get(src);
+        if (!cached)
+            return null;
+        return { width: cached.width, height: cached.height };
+    };
+    const ensureImageSize = async (src) => {
+        if (!src)
+            return null;
+        const cached = sizesBySrc.get(src);
+        if (cached)
+            return { width: cached.width, height: cached.height };
+        const pending = pendingBySrc.get(src);
+        if (pending) {
+            return pending;
+        }
+        const task = loadSize(src);
+        pendingBySrc.set(src, task);
+        try {
+            const size = await task;
+            if (size) {
+                rememberSourceSize(src, size);
+            }
+            return size;
+        }
+        finally {
+            if (pendingBySrc.get(src) === task) {
+                pendingBySrc.delete(src);
+            }
+        }
+    };
+    const deleteSourceSize = (src) => {
+        if (!src)
+            return;
+        sizesBySrc.delete(src);
+        pendingBySrc.delete(src);
+    };
+    const clear = () => {
+        sizesBySrc.clear();
+        pendingBySrc.clear();
+    };
+    return {
+        ensureImageSize,
+        rememberSourceSize,
+        getSourceSize,
+        deleteSourceSize,
+        clear,
+    };
+}

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

@@ -0,0 +1,22 @@
+"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("./constants/layers"), exports);
+__exportStar(require("./imaging/sourceSizeCache"), exports);
+__exportStar(require("./runtime/sessionState"), exports);
+__exportStar(require("./runtime/subscriptions"), exports);
+__exportStar(require("./scene/frame"), exports);
+__exportStar(require("./scene/sceneLayoutModel"), exports);

package/.test-dist/src/shared/runtime/sessionState.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkingSessionState = void 0;
+exports.cloneWithJson = cloneWithJson;
+exports.applyCommittedSnapshot = applyCommittedSnapshot;
+exports.runDeferredConfigUpdate = runDeferredConfigUpdate;
+function cloneWithJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function applyCommittedSnapshot(session, nextCommitted, options) {
+    const clone = options.clone;
+    session.committed = clone(nextCommitted);
+    const shouldPreserveDirtyWorking = options.toolActive &&
+        options.preserveDirtyWorking !== false &&
+        session.hasWorkingChanges;
+    if (!shouldPreserveDirtyWorking) {
+        session.working = clone(session.committed);
+        session.hasWorkingChanges = false;
+    }
+}
+function runDeferredConfigUpdate(state, action, cooldownMs = 0) {
+    state.isUpdatingConfig = true;
+    action();
+    if (cooldownMs <= 0) {
+        state.isUpdatingConfig = false;
+        return;
+    }
+    setTimeout(() => {
+        state.isUpdatingConfig = false;
+    }, cooldownMs);
+}
+class WorkingSessionState {
+    constructor(initial, clone) {
+        this.hasWorkingChanges = false;
+        this.isUpdatingConfig = false;
+        this.clone = clone;
+        this.committed = this.clone(initial);
+        this.working = this.clone(initial);
+    }
+    setCommitted(next, options = {}) {
+        this.committed = this.clone(next);
+        const shouldPreserveDirtyWorking = options.toolActive === true &&
+            options.preserveDirtyWorking !== false &&
+            this.hasWorkingChanges;
+        if (!shouldPreserveDirtyWorking) {
+            this.working = this.clone(this.committed);
+            this.hasWorkingChanges = false;
+        }
+    }
+    setWorking(next, options = {}) {
+        this.working = this.clone(next);
+        if (options.markDirty !== false) {
+            this.hasWorkingChanges = true;
+        }
+    }
+    resetWorkingFromCommitted() {
+        this.working = this.clone(this.committed);
+        this.hasWorkingChanges = false;
+    }
+    commitWorkingToCommitted() {
+        this.committed = this.clone(this.working);
+        this.hasWorkingChanges = false;
+    }
+    runConfigUpdate(action) {
+        this.isUpdatingConfig = true;
+        try {
+            action();
+        }
+        finally {
+            this.isUpdatingConfig = false;
+        }
+    }
+}
+exports.WorkingSessionState = WorkingSessionState;

package/.test-dist/src/shared/runtime/subscriptions.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionBag = void 0;
+class SubscriptionBag {
+    constructor() {
+        this.disposables = [];
+    }
+    add(disposable) {
+        if (disposable) {
+            this.disposables.push(disposable);
+        }
+        return disposable;
+    }
+    on(eventBus, event, handler) {
+        eventBus.on(event, handler);
+        this.disposables.push({
+            dispose: () => eventBus.off(event, handler),
+        });
+    }
+    onConfigChange(configService, handler) {
+        this.add(configService.onAnyChange(handler));
+    }
+    disposeAll() {
+        while (this.disposables.length > 0) {
+            const disposable = this.disposables.pop();
+            disposable?.dispose();
+        }
+    }
+}
+exports.SubscriptionBag = SubscriptionBag;

package/.test-dist/src/shared/scene/frame.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyFrameRect = emptyFrameRect;
+exports.resolveCutFrameRect = resolveCutFrameRect;
+exports.toLayoutSceneRect = toLayoutSceneRect;
+const sceneLayoutModel_1 = require("./sceneLayoutModel");
+function emptyFrameRect() {
+    return { left: 0, top: 0, width: 0, height: 0 };
+}
+function resolveCutFrameRect(canvasService, configService) {
+    if (!canvasService || !configService) {
+        return emptyFrameRect();
+    }
+    const sizeState = (0, sceneLayoutModel_1.readSizeState)(configService);
+    const layout = (0, sceneLayoutModel_1.computeSceneLayout)(canvasService, sizeState);
+    if (!layout) {
+        return emptyFrameRect();
+    }
+    return canvasService.toSceneRect({
+        left: layout.cutRect.left,
+        top: layout.cutRect.top,
+        width: layout.cutRect.width,
+        height: layout.cutRect.height,
+    });
+}
+function toLayoutSceneRect(rect) {
+    return {
+        left: rect.left,
+        top: rect.top,
+        width: rect.width,
+        height: rect.height,
+        space: "scene",
+    };
+}