@pooder/kit 6.2.2 → 6.3.1

package/.test-dist/src/extensions/image/commands.js

@@ -24,30 +24,43 @@ function createImageCommands(tool) {
             },
         },
         {
-            command: "getWorkingImages",
-            id: "getWorkingImages",
-            title: "Get Working Images",
+            command: "applyImageOperation",
+            id: "applyImageOperation",
+            title: "Apply Image Operation",
+            handler: async (id, operation, options = {}) => {
+                await tool.applyImageOperation(id, operation, options);
+            },
+        },
+        {
+            command: "getImageViewState",
+            id: "getImageViewState",
+            title: "Get Image View State",
             handler: () => {
-                return tool.cloneItems(tool.workingItems);
+                return tool.getImageViewState();
             },
         },
         {
-            command: "setWorkingImage",
-            id: "setWorkingImage",
-            title: "Set Working Image",
-            handler: (id, updates) => {
-                tool.updateImageInWorking(id, updates);
+            command: "setImageTransform",
+            id: "setImageTransform",
+            title: "Set Image Transform",
+            handler: async (id, updates, options = {}) => {
+                await tool.setImageTransform(id, updates, options);
             },
         },
         {
-            command: "resetWorkingImages",
-            id: "resetWorkingImages",
-            title: "Reset Working Images",
+            command: "imageSessionReset",
+            id: "imageSessionReset",
+            title: "Reset Image Session",
             handler: () => {
-                tool.workingItems = tool.cloneItems(tool.items);
-                tool.hasWorkingChanges = false;
-                tool.updateImages();
-                tool.emitWorkingChange();
+                tool.resetImageSession();
+            },
+        },
+        {
+            command: "validateImageSession",
+            id: "validateImageSession",
+            title: "Validate Image Session",
+            handler: async () => {
+                return await tool.validateImageSession();
             },
         },
         {
@@ -55,7 +68,7 @@ function createImageCommands(tool) {
             id: "completeImages",
             title: "Complete Images",
             handler: async () => {
-                return await tool.commitWorkingImagesAsCropped();
+                return await tool.completeImageSession();
             },
         },
         {
@@ -66,22 +79,6 @@ function createImageCommands(tool) {
                 return await tool.exportUserCroppedImage(options);
             },
         },
-        {
-            command: "fitImageToArea",
-            id: "fitImageToArea",
-            title: "Fit Image to Area",
-            handler: async (id, area) => {
-                await tool.fitImageToArea(id, area);
-            },
-        },
-        {
-            command: "fitImageToDefaultArea",
-            id: "fitImageToDefaultArea",
-            title: "Fit Image to Default Area",
-            handler: async (id) => {
-                await tool.fitImageToDefaultArea(id);
-            },
-        },
         {
             command: "focusImage",
             id: "focusImage",
@@ -95,9 +92,10 @@ function createImageCommands(tool) {
             id: "removeImage",
             title: "Remove Image",
             handler: (id) => {
-                const removed = tool.items.find((item) => item.id === id);
-                const next = tool.items.filter((item) => item.id !== id);
-                if (next.length !== tool.items.length) {
+                const sourceItems = tool.isToolActive ? tool.workingItems : tool.items;
+                const removed = sourceItems.find((item) => item.id === id);
+                const next = sourceItems.filter((item) => item.id !== id);
+                if (next.length !== sourceItems.length) {
                     tool.purgeSourceSizeCacheForItem(removed);
                     if (tool.focusedImageId === id) {
                         tool.setImageFocus(null, {
@@ -105,6 +103,13 @@ function createImageCommands(tool) {
                             skipRender: true,
                         });
                     }
+                    if (tool.isToolActive) {
+                        tool.workingItems = tool.cloneItems(next);
+                        tool.hasWorkingChanges = true;
+                        tool.updateImages();
+                        tool.emitWorkingChange(id);
+                        return;
+                    }
                     tool.updateConfig(next);
                 }
             },
@@ -127,6 +132,13 @@ function createImageCommands(tool) {
                     syncCanvasSelection: true,
                     skipRender: true,
                 });
+                if (tool.isToolActive) {
+                    tool.workingItems = [];
+                    tool.hasWorkingChanges = true;
+                    tool.updateImages();
+                    tool.emitWorkingChange();
+                    return;
+                }
                 tool.updateConfig([]);
             },
         },
@@ -135,11 +147,19 @@ function createImageCommands(tool) {
             id: "bringToFront",
             title: "Bring Image to Front",
             handler: (id) => {
-                const index = tool.items.findIndex((item) => item.id === id);
-                if (index !== -1 && index < tool.items.length - 1) {
-                    const next = [...tool.items];
+                const sourceItems = tool.isToolActive ? tool.workingItems : tool.items;
+                const index = sourceItems.findIndex((item) => item.id === id);
+                if (index !== -1 && index < sourceItems.length - 1) {
+                    const next = [...sourceItems];
                     const [item] = next.splice(index, 1);
                     next.push(item);
+                    if (tool.isToolActive) {
+                        tool.workingItems = tool.cloneItems(next);
+                        tool.hasWorkingChanges = true;
+                        tool.updateImages();
+                        tool.emitWorkingChange(id);
+                        return;
+                    }
                     tool.updateConfig(next);
                 }
             },
@@ -149,11 +169,19 @@ function createImageCommands(tool) {
             id: "sendToBack",
             title: "Send Image to Back",
             handler: (id) => {
-                const index = tool.items.findIndex((item) => item.id === id);
+                const sourceItems = tool.isToolActive ? tool.workingItems : tool.items;
+                const index = sourceItems.findIndex((item) => item.id === id);
                 if (index > 0) {
-                    const next = [...tool.items];
+                    const next = [...sourceItems];
                     const [item] = next.splice(index, 1);
                     next.unshift(item);
+                    if (tool.isToolActive) {
+                        tool.workingItems = tool.cloneItems(next);
+                        tool.hasWorkingChanges = true;
+                        tool.updateImages();
+                        tool.emitWorkingChange(id);
+                        return;
+                    }
                     tool.updateConfig(next);
                 }
             },

package/.test-dist/src/extensions/image/config.js

@@ -125,5 +125,12 @@ function createImageConfigurations() {
             label: "Image Frame Outer Background",
             default: "#f5f5f5",
         },
+        {
+            id: "image.session.placementPolicy",
+            type: "select",
+            label: "Image Session Placement Policy",
+            options: ["free", "warn", "strict"],
+            default: "free",
+        },
     ];
 }

package/.test-dist/src/extensions/image/imageOperations.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveImageOperationArea = resolveImageOperationArea;
+exports.computeImageOperationUpdates = computeImageOperationUpdates;
+const sourceSizeCache_1 = require("../../shared/imaging/sourceSizeCache");
+function clampNormalizedAnchor(value) {
+    return Math.max(-1, Math.min(2, value));
+}
+function toNormalizedAnchor(center, start, size) {
+    return clampNormalizedAnchor((center - start) / Math.max(1, size));
+}
+function resolveAbsoluteScale(operation, area, source) {
+    const widthScale = Math.max(1, area.width) / Math.max(1, source.width);
+    const heightScale = Math.max(1, area.height) / Math.max(1, source.height);
+    switch (operation.type) {
+        case "cover":
+            return Math.max(widthScale, heightScale);
+        case "contain":
+            return Math.min(widthScale, heightScale);
+        case "maximizeWidth":
+            return widthScale;
+        case "maximizeHeight":
+            return heightScale;
+        default:
+            return null;
+    }
+}
+function resolveImageOperationArea(args) {
+    const spec = args.area || { type: "frame" };
+    if (spec.type === "custom") {
+        return {
+            width: Math.max(1, spec.width),
+            height: Math.max(1, spec.height),
+            centerX: spec.centerX,
+            centerY: spec.centerY,
+        };
+    }
+    if (spec.type === "viewport") {
+        return {
+            width: Math.max(1, args.viewport.width),
+            height: Math.max(1, args.viewport.height),
+            centerX: args.viewport.left + args.viewport.width / 2,
+            centerY: args.viewport.top + args.viewport.height / 2,
+        };
+    }
+    return {
+        width: Math.max(1, args.frame.width),
+        height: Math.max(1, args.frame.height),
+        centerX: args.frame.left + args.frame.width / 2,
+        centerY: args.frame.top + args.frame.height / 2,
+    };
+}
+function computeImageOperationUpdates(args) {
+    const { frame, source, operation, area } = args;
+    if (operation.type === "resetTransform") {
+        return {
+            scale: 1,
+            left: 0.5,
+            top: 0.5,
+            angle: 0,
+        };
+    }
+    const left = toNormalizedAnchor(area.centerX, frame.left, frame.width);
+    const top = toNormalizedAnchor(area.centerY, frame.top, frame.height);
+    if (operation.type === "center") {
+        return { left, top };
+    }
+    const absoluteScale = resolveAbsoluteScale(operation, area, source);
+    const coverScale = (0, sourceSizeCache_1.getCoverScale)(frame, source);
+    return {
+        scale: Math.max(0.05, (absoluteScale || coverScale) / coverScale),
+        left,
+        top,
+    };
+}

package/.test-dist/src/extensions/image/imagePlacement.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateImagePlacement = validateImagePlacement;
+const sourceSizeCache_1 = require("../../shared/imaging/sourceSizeCache");
+function toRadians(angle) {
+    return (angle * Math.PI) / 180;
+}
+function validateImagePlacement(args) {
+    const { frame, source, placement } = args;
+    if (frame.width <= 0 ||
+        frame.height <= 0 ||
+        source.width <= 0 ||
+        source.height <= 0) {
+        return { ok: true };
+    }
+    const coverScale = (0, sourceSizeCache_1.getCoverScale)(frame, source);
+    const imageWidth = source.width * coverScale * Math.max(0.05, Number(placement.scale || 1));
+    const imageHeight = source.height * coverScale * Math.max(0.05, Number(placement.scale || 1));
+    if (imageWidth <= 0 || imageHeight <= 0) {
+        return { ok: true };
+    }
+    const centerX = frame.left + placement.left * frame.width;
+    const centerY = frame.top + placement.top * frame.height;
+    const halfWidth = imageWidth / 2;
+    const halfHeight = imageHeight / 2;
+    const radians = toRadians(placement.angle || 0);
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    const frameCorners = [
+        { x: frame.left, y: frame.top },
+        { x: frame.left + frame.width, y: frame.top },
+        { x: frame.left + frame.width, y: frame.top + frame.height },
+        { x: frame.left, y: frame.top + frame.height },
+    ];
+    const coversFrame = frameCorners.every((corner) => {
+        const dx = corner.x - centerX;
+        const dy = corner.y - centerY;
+        const localX = dx * cos + dy * sin;
+        const localY = -dx * sin + dy * cos;
+        return (Math.abs(localX) <= halfWidth + 1e-6 &&
+            Math.abs(localY) <= halfHeight + 1e-6);
+    });
+    return { ok: coversFrame };
+}

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

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ImageTool"), exports);
 __exportStar(require("./commands"), exports);
 __exportStar(require("./config"), exports);
+__exportStar(require("./imageOperations"), exports);
 __exportStar(require("./model"), exports);
 __exportStar(require("./renderer"), exports);

package/.test-dist/src/extensions/image/model.js

@@ -1,2 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAnyImageInViewState = hasAnyImageInViewState;
+function hasAnyImageInViewState(state) {
+    return Boolean(state?.hasAnyImage);
+}

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

@@ -12,6 +12,7 @@ const config_2 = require("../src/extensions/white-ink/config");
 const commands_3 = require("../src/extensions/dieline/commands");
 const config_3 = require("../src/extensions/dieline/config");
 const featureCoordinates_1 = require("../src/extensions/featureCoordinates");
+const model_1 = require("../src/extensions/image/model");
 function assert(condition, message) {
     if (!condition)
         throw new Error(message);
@@ -66,10 +67,12 @@ function testMaskOps() {
     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 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, {
@@ -169,6 +172,43 @@ function testVisibilityDsl() {
         ],
     }, context) === true, "any failed");
 }
+function testImageViewStateHelper() {
+    assert((0, model_1.hasAnyImageInViewState)(null) === false, "null image state should be empty");
+    assert((0, model_1.hasAnyImageInViewState)({
+        items: [],
+        hasAnyImage: false,
+        focusedId: null,
+        focusedItem: null,
+        isToolActive: false,
+        isImageSelectionActive: false,
+        hasWorkingChanges: false,
+        source: "committed",
+        placementPolicy: "free",
+        sessionNotice: null,
+    }) === false, "empty image state should report false");
+    assert((0, model_1.hasAnyImageInViewState)({
+        items: [
+            {
+                id: "img-1",
+                url: "blob:test",
+                opacity: 1,
+            },
+        ],
+        hasAnyImage: true,
+        focusedId: "img-1",
+        focusedItem: {
+            id: "img-1",
+            url: "blob:test",
+            opacity: 1,
+        },
+        isToolActive: true,
+        isImageSelectionActive: true,
+        hasWorkingChanges: true,
+        source: "working",
+        placementPolicy: "free",
+        sessionNotice: null,
+    }) === true, "non-empty image state should report true");
+}
 function testContributionCompatibility() {
     const imageCommandNames = (0, commands_1.createImageCommands)({}).map((entry) => entry.command);
     const whiteInkCommandNames = (0, commands_2.createWhiteInkCommands)({}).map((entry) => entry.command);
@@ -179,13 +219,13 @@ function testContributionCompatibility() {
     const expectedImageCommands = [
         "addImage",
         "upsertImage",
-        "getWorkingImages",
-        "setWorkingImage",
-        "resetWorkingImages",
+        "applyImageOperation",
+        "getImageViewState",
+        "setImageTransform",
+        "imageSessionReset",
+        "validateImageSession",
         "completeImages",
         "exportUserCroppedImage",
-        "fitImageToArea",
-        "fitImageToDefaultArea",
         "focusImage",
         "removeImage",
         "updateImage",
@@ -249,6 +289,7 @@ function testContributionCompatibility() {
         "image.frame.dashLength",
         "image.frame.innerBackground",
         "image.frame.outerBackground",
+        "image.session.placementPolicy",
     ];
     const expectedWhiteInkConfigKeys = [
         "whiteInk.items",
@@ -285,6 +326,7 @@ function main() {
     testEdgeScale();
     testFeaturePlacementProjection();
     testVisibilityDsl();
+    testImageViewStateHelper();
     testContributionCompatibility();
     console.log("ok");
 }

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @pooder/kit
 
+## 6.3.1
+
+### Patch Changes
+
+- image placement constraint
+- Updated dependencies
+  - @pooder/core@2.2.2
+
+## 6.3.0
+
+### Minor Changes
+
+- pooder facade
+
 ## 6.2.2
 
 ### Patch Changes