@pooder/kit 6.2.2 → 6.3.0

package/src/extensions/image/imageOperations.ts

@@ -0,0 +1,135 @@
+import type { FrameRect } from "../../shared/scene/frame";
+import {
+  getCoverScale as getCoverScaleFromRect,
+  type SourceSize,
+} from "../../shared/imaging/sourceSizeCache";
+
+export interface ImageOperationArea {
+  width: number;
+  height: number;
+  centerX: number;
+  centerY: number;
+}
+
+export interface ImageOperationViewport {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+}
+
+export type ImageOperationAreaSpec =
+  | { type: "frame" }
+  | { type: "viewport" }
+  | ({
+      type: "custom";
+    } & ImageOperationArea);
+
+export type ImageOperation =
+  | { type: "cover"; area?: ImageOperationAreaSpec }
+  | { type: "contain"; area?: ImageOperationAreaSpec }
+  | { type: "maximizeWidth"; area?: ImageOperationAreaSpec }
+  | { type: "maximizeHeight"; area?: ImageOperationAreaSpec }
+  | { type: "center"; area?: ImageOperationAreaSpec }
+  | { type: "resetTransform" };
+
+export interface ComputeImageOperationArgs {
+  frame: FrameRect;
+  source: SourceSize;
+  operation: ImageOperation;
+  area: ImageOperationArea;
+}
+
+function clampNormalizedAnchor(value: number): number {
+  return Math.max(-1, Math.min(2, value));
+}
+
+function toNormalizedAnchor(center: number, start: number, size: number): number {
+  return clampNormalizedAnchor((center - start) / Math.max(1, size));
+}
+
+function resolveAbsoluteScale(
+  operation: ImageOperation,
+  area: ImageOperationArea,
+  source: SourceSize,
+): number | null {
+  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;
+  }
+}
+
+export function resolveImageOperationArea(args: {
+  frame: FrameRect;
+  viewport: ImageOperationViewport;
+  area?: ImageOperationAreaSpec;
+}): ImageOperationArea {
+  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,
+  };
+}
+
+export function computeImageOperationUpdates(
+  args: ComputeImageOperationArgs,
+): { scale?: number; left?: number; top?: number; angle?: number } {
+  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 = getCoverScaleFromRect(frame, source);
+
+  return {
+    scale: Math.max(0.05, (absoluteScale || coverScale) / coverScale),
+    left,
+    top,
+  };
+}

package/src/extensions/image/index.ts

@@ -1,5 +1,6 @@
 export * from "./ImageTool";
 export * from "./commands";
 export * from "./config";
+export * from "./imageOperations";
 export * from "./model";
 export * from "./renderer";

package/src/extensions/image/model.ts

@@ -1 +1,13 @@
-export type { ImageItem } from "./ImageTool";
+export type {
+  ImageItem,
+  ImageTransformUpdates,
+  ImageViewState,
+} from "./ImageTool";
+
+import type { ImageViewState } from "./ImageTool";
+
+export function hasAnyImageInViewState(
+  state: ImageViewState | null | undefined,
+): boolean {
+  return Boolean(state?.hasAnyImage);
+}

package/tests/run.ts

@@ -25,6 +25,7 @@ import {
   normalizePointInGeometry,
   resolveFeaturePosition,
 } from "../src/extensions/featureCoordinates";
+import { hasAnyImageInViewState } from "../src/extensions/image/model";
 
 function assert(condition: unknown, message: string) {
   if (!condition) throw new Error(message);
@@ -288,6 +289,46 @@ function testVisibilityDsl() {
   );
 }
 
+function testImageViewStateHelper() {
+  assert(hasAnyImageInViewState(null) === false, "null image state should be empty");
+  assert(
+    hasAnyImageInViewState({
+      items: [],
+      hasAnyImage: false,
+      focusedId: null,
+      focusedItem: null,
+      isToolActive: false,
+      isImageSelectionActive: false,
+      hasWorkingChanges: false,
+      source: "committed",
+    }) === false,
+    "empty image state should report false",
+  );
+  assert(
+    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",
+    }) === true,
+    "non-empty image state should report true",
+  );
+}
+
 function testContributionCompatibility() {
   const imageCommandNames = createImageCommands({} as any).map(
     (entry) => entry.command,
@@ -303,13 +344,12 @@ function testContributionCompatibility() {
   const expectedImageCommands = [
     "addImage",
     "upsertImage",
-    "getWorkingImages",
-    "setWorkingImage",
-    "resetWorkingImages",
+    "applyImageOperation",
+    "getImageViewState",
+    "setImageTransform",
+    "imageSessionReset",
     "completeImages",
     "exportUserCroppedImage",
-    "fitImageToArea",
-    "fitImageToDefaultArea",
     "focusImage",
     "removeImage",
     "updateImage",
@@ -432,9 +472,10 @@ function main() {
   testBridgeSelection();
   testMaskOps();
   testEdgeScale();
-  testFeaturePlacementProjection();
-  testVisibilityDsl();
-  testContributionCompatibility();
+testFeaturePlacementProjection();
+testVisibilityDsl();
+testImageViewStateHelper();
+testContributionCompatibility();
   console.log("ok");
 }