@pooder/kit 6.1.1 → 6.2.0

package/.test-dist/src/extensions/background/BackgroundTool.js

@@ -22,7 +22,7 @@ const DEFAULT_BACKGROUND_CONFIG = {
             order: 0,
             enabled: true,
             exportable: false,
-            color: "#fff",
+            color: "#eee",
         },
     ],
 };
@@ -45,6 +45,22 @@ function normalizeFitMode(value, fallback) {
     }
     return fallback;
 }
+function normalizeRegionUnit(value, fallback) {
+    if (value === "px" || value === "normalized") {
+        return value;
+    }
+    return fallback;
+}
+function normalizeRegistrationFrame(value, fallback) {
+    if (value === "trim" ||
+        value === "cut" ||
+        value === "bleed" ||
+        value === "focus" ||
+        value === "viewport") {
+        return value;
+    }
+    return fallback;
+}
 function normalizeAnchor(value, fallback) {
     if (typeof value !== "string")
         return fallback;
@@ -57,6 +73,64 @@ function normalizeOrder(value, fallback) {
         return fallback;
     return numeric;
 }
+function normalizeRegionValue(value, fallback) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : fallback;
+}
+function normalizeRegistrationRegion(raw, fallback) {
+    if (!raw || typeof raw !== "object") {
+        return fallback ? { ...fallback } : undefined;
+    }
+    const input = raw;
+    const base = fallback || {
+        left: 0,
+        top: 0,
+        width: 1,
+        height: 1,
+        unit: "normalized",
+    };
+    return {
+        left: normalizeRegionValue(input.left, base.left),
+        top: normalizeRegionValue(input.top, base.top),
+        width: normalizeRegionValue(input.width, base.width),
+        height: normalizeRegionValue(input.height, base.height),
+        unit: normalizeRegionUnit(input.unit, base.unit),
+    };
+}
+function normalizeRegistration(raw, fallback) {
+    if (!raw || typeof raw !== "object") {
+        return fallback
+            ? {
+                sourceRegion: fallback.sourceRegion
+                    ? { ...fallback.sourceRegion }
+                    : undefined,
+                targetFrame: fallback.targetFrame,
+                fit: fallback.fit,
+            }
+            : undefined;
+    }
+    const input = raw;
+    const normalized = {
+        sourceRegion: normalizeRegistrationRegion(input.sourceRegion, fallback?.sourceRegion),
+        targetFrame: normalizeRegistrationFrame(input.targetFrame, fallback?.targetFrame || "trim"),
+        fit: normalizeFitMode(input.fit, fallback?.fit || "stretch"),
+    };
+    if (!normalized.sourceRegion) {
+        return undefined;
+    }
+    return normalized;
+}
+function cloneRegistration(registration) {
+    if (!registration)
+        return undefined;
+    return {
+        sourceRegion: registration.sourceRegion
+            ? { ...registration.sourceRegion }
+            : undefined,
+        targetFrame: registration.targetFrame,
+        fit: registration.fit,
+    };
+}
 function normalizeLayer(raw, index, fallback) {
     const fallbackLayer = fallback || {
         id: `layer-${index + 1}`,
@@ -70,7 +144,10 @@ function normalizeLayer(raw, index, fallback) {
         src: "",
     };
     if (!raw || typeof raw !== "object") {
-        return { ...fallbackLayer };
+        return {
+            ...fallbackLayer,
+            registration: cloneRegistration(fallbackLayer.registration),
+        };
     }
     const input = raw;
     const kind = normalizeLayerKind(input.kind, fallbackLayer.kind);
@@ -103,6 +180,9 @@ function normalizeLayer(raw, index, fallback) {
                     ? fallbackLayer.src
                     : ""
             : undefined,
+        registration: kind === "image"
+            ? normalizeRegistration(input.registration, fallbackLayer.registration)
+            : undefined,
     };
 }
 function normalizeConfig(raw) {
@@ -136,7 +216,10 @@ function normalizeConfig(raw) {
 function cloneConfig(config) {
     return {
         version: config.version,
-        layers: (config.layers || []).map((layer) => ({ ...layer })),
+        layers: (config.layers || []).map((layer) => ({
+            ...layer,
+            registration: cloneRegistration(layer.registration),
+        })),
     };
 }
 function mergeConfig(base, patch) {
@@ -353,6 +436,41 @@ class BackgroundTool {
             height: layout.trimRect.height,
         };
     }
+    resolveTargetFrameRect(frame) {
+        if (frame === "viewport") {
+            return this.getViewportRect();
+        }
+        const layout = this.resolveSceneLayout();
+        if (!layout) {
+            return frame === "focus" ? this.getViewportRect() : null;
+        }
+        switch (frame) {
+            case "trim":
+            case "focus":
+                return {
+                    left: layout.trimRect.left,
+                    top: layout.trimRect.top,
+                    width: layout.trimRect.width,
+                    height: layout.trimRect.height,
+                };
+            case "cut":
+                return {
+                    left: layout.cutRect.left,
+                    top: layout.cutRect.top,
+                    width: layout.cutRect.width,
+                    height: layout.cutRect.height,
+                };
+            case "bleed":
+                return {
+                    left: layout.bleedRect.left,
+                    top: layout.bleedRect.top,
+                    width: layout.bleedRect.width,
+                    height: layout.bleedRect.height,
+                };
+            default:
+                return null;
+        }
+    }
     resolveAnchorRect(anchor) {
         if (anchor === "focus") {
             return this.resolveFocusRect() || this.getViewportRect();
@@ -387,6 +505,60 @@ class BackgroundTool {
             scaleY: scale,
         };
     }
+    resolveRegistrationRegion(region, sourceSize) {
+        const sourceWidth = Math.max(1, Number(sourceSize.width || 0));
+        const sourceHeight = Math.max(1, Number(sourceSize.height || 0));
+        const width = region.unit === "normalized" ? region.width * sourceWidth : region.width;
+        const height = region.unit === "normalized"
+            ? region.height * sourceHeight
+            : region.height;
+        const left = region.unit === "normalized" ? region.left * sourceWidth : region.left;
+        const top = region.unit === "normalized" ? region.top * sourceHeight : region.top;
+        if (!Number.isFinite(left) ||
+            !Number.isFinite(top) ||
+            !Number.isFinite(width) ||
+            !Number.isFinite(height) ||
+            width <= 0 ||
+            height <= 0) {
+            return null;
+        }
+        return { left, top, width, height };
+    }
+    resolveRegistrationPlacement(layer, sourceSize) {
+        const registration = layer.registration;
+        if (!registration?.sourceRegion)
+            return null;
+        const targetRect = this.resolveTargetFrameRect(registration.targetFrame || "trim");
+        if (!targetRect)
+            return null;
+        const sourceRegion = this.resolveRegistrationRegion(registration.sourceRegion, sourceSize);
+        if (!sourceRegion)
+            return null;
+        const fit = registration.fit || "stretch";
+        const baseScaleX = targetRect.width / sourceRegion.width;
+        const baseScaleY = targetRect.height / sourceRegion.height;
+        if (fit === "stretch") {
+            return {
+                left: targetRect.left - sourceRegion.left * baseScaleX,
+                top: targetRect.top - sourceRegion.top * baseScaleY,
+                scaleX: baseScaleX,
+                scaleY: baseScaleY,
+            };
+        }
+        const uniformScale = fit === "contain"
+            ? Math.min(baseScaleX, baseScaleY)
+            : Math.max(baseScaleX, baseScaleY);
+        const alignedWidth = sourceRegion.width * uniformScale;
+        const alignedHeight = sourceRegion.height * uniformScale;
+        const offsetLeft = targetRect.left + (targetRect.width - alignedWidth) / 2;
+        const offsetTop = targetRect.top + (targetRect.height - alignedHeight) / 2;
+        return {
+            left: offsetLeft - sourceRegion.left * uniformScale,
+            top: offsetTop - sourceRegion.top * uniformScale,
+            scaleX: uniformScale,
+            scaleY: uniformScale,
+        };
+    }
     buildColorLayerSpec(layer) {
         const rect = this.resolveAnchorRect(layer.anchor);
         return {
@@ -422,8 +594,8 @@ class BackgroundTool {
         const sourceSize = this.sourceSizeCache.getSourceSize(src);
         if (!sourceSize)
             return [];
-        const rect = this.resolveAnchorRect(layer.anchor);
-        const placement = this.resolveImagePlacement(rect, sourceSize, layer.fit);
+        const placement = this.resolveRegistrationPlacement(layer, sourceSize) ||
+            this.resolveImagePlacement(this.resolveAnchorRect(layer.anchor), sourceSize, layer.fit);
         return [
             {
                 id: `background.layer.${layer.id}.image`,

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPathConstraintProbePoint = getPathConstraintProbePoint;
+function getPathConstraintProbePoint(args) {
+    const { x, y, geometry, feature } = args;
+    const minX = geometry.x - geometry.width / 2;
+    const minY = geometry.y - geometry.height / 2;
+    const maxX = minX + geometry.width;
+    const maxY = minY + geometry.height;
+    const absX = minX + x * geometry.width;
+    const absY = minY + y * geometry.height;
+    const minEdgeDistance = Math.min(x, 1 - x, y, 1 - y);
+    const isAnchoredToBoundary = x <= 0 || x >= 1 || y <= 0 || y >= 1 || minEdgeDistance <= 1e-6;
+    if (!isAnchoredToBoundary) {
+        return { x: absX, y: absY };
+    }
+    const clampedX = Math.max(0, Math.min(1, x));
+    const clampedY = Math.max(0, Math.min(1, y));
+    const halfFeatureExtent = feature?.shape === "circle"
+        ? Math.max(0, feature?.radius || 0)
+        : Math.max(0, (feature?.width || 0) / 2, (feature?.height || 0) / 2);
+    const outsidePad = Math.max(1e-3, halfFeatureExtent, Math.min(geometry.width, geometry.height) * 0.02);
+    let probeX = minX + clampedX * geometry.width;
+    let probeY = minY + clampedY * geometry.height;
+    const distances = [
+        { edge: "top", dist: Math.abs(y) },
+        { edge: "bottom", dist: Math.abs(1 - y) },
+        { edge: "left", dist: Math.abs(x) },
+        { edge: "right", dist: Math.abs(1 - x) },
+    ];
+    const nearestDist = Math.min(...distances.map((entry) => entry.dist));
+    const activeEdges = distances
+        .filter((entry) => Math.abs(entry.dist - nearestDist) <= 1e-6)
+        .map((entry) => entry.edge);
+    if (activeEdges.includes("top"))
+        probeY = minY - outsidePad;
+    if (activeEdges.includes("bottom"))
+        probeY = maxY + outsidePad;
+    if (activeEdges.includes("left"))
+        probeX = minX - outsidePad;
+    if (activeEdges.includes("right"))
+        probeX = maxX + outsidePad;
+    return { x: probeX, y: probeY };
+}