refactor(transform): resolve target bounds

editor/transform-targets.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import type { ImageDocument } from "@core/document";
+import { applyTransformTargetBounds, resolveTransformTargetBounds, selectedTransformTarget } from "./transform-targets";
+
+const document: ImageDocument = {
+  id: "d1",
+  name: "Test",
+  version: 1,
+  assets: [],
+  artboards: [
+    {
+      id: "a1",
+      name: "Artboard",
+      bounds: { x: 0, y: 0, w: 100, h: 80 },
+      backgroundColor: "transparent",
+      layers: [],
+    },
+  ],
+};
+
+describe("transform targets", () => {
+  test("selects layer target before artboard target", () => {
+    expect(selectedTransformTarget(document, { artboardId: "a1", layerIds: ["l1"] })).toEqual({ type: "layer", id: "l1" });
+  });
+
+  test("resolves artboard bounds", () => {
+    expect(resolveTransformTargetBounds(document, { type: "artboard", id: "a1" })).toEqual({ x: 0, y: 0, w: 100, h: 80 });
+  });
+
+  test("applies artboard bounds", () => {
+    const next = applyTransformTargetBounds(document, { type: "artboard", id: "a1" }, { x: 10, y: 20, w: 200, h: 160 });
+    expect(next.artboards[0]?.bounds).toEqual({ x: 10, y: 20, w: 200, h: 160 });
+  });
+});

editor/transform-targets.ts

@@ -0,0 +1,78 @@
+import type { ImageDocument } from "@core/document";
+import type { Rect } from "@core/geometry";
+import type { Layer } from "@core/layer";
+import type { ArtboardId, LayerId } from "@core/id";
+import type { TransformTarget } from "./transform";
+
+export function resolveTransformTargetBounds(document: ImageDocument, target: TransformTarget): Rect | undefined {
+  switch (target.type) {
+    case "artboard":
+      return document.artboards.find((artboard) => artboard.id === target.id)?.bounds;
+    case "layer": {
+      const layer = findLayer(document, target.id);
+      return layer ? resolveLayerBounds(layer) : undefined;
+    }
+  }
+}
+
+export function applyTransformTargetBounds(document: ImageDocument, target: TransformTarget, bounds: Rect): ImageDocument {
+  switch (target.type) {
+    case "artboard":
+      return {
+        ...document,
+        artboards: document.artboards.map((artboard) => (artboard.id === target.id ? { ...artboard, bounds: { ...bounds } } : artboard)),
+      };
+    case "layer":
+      return document;
+  }
+}
+
+export function selectedTransformTarget(document: ImageDocument, selection: { artboardId?: ArtboardId; layerIds: LayerId[] }): TransformTarget | undefined {
+  if (selection.layerIds.length === 1 && selection.layerIds[0]) return { type: "layer", id: selection.layerIds[0] };
+  if (selection.artboardId) return { type: "artboard", id: selection.artboardId };
+  return undefined;
+}
+
+function findLayer(document: ImageDocument, layerId: LayerId): Layer | undefined {
+  for (const artboard of document.artboards) {
+    const layer = findLayerInTree(artboard.layers, layerId);
+    if (layer) return layer;
+  }
+
+  return undefined;
+}
+
+function findLayerInTree(layers: Layer[], layerId: LayerId): Layer | undefined {
+  for (const layer of layers) {
+    if (layer.id === layerId) return layer;
+    if (layer.type === "group") {
+      const child = findLayerInTree(layer.children, layerId);
+      if (child) return child;
+    }
+  }
+
+  return undefined;
+}
+
+function resolveLayerBounds(layer: Layer): Rect | undefined {
+  switch (layer.type) {
+    case "group":
+      return unionRects(layer.children.flatMap((child) => {
+        const bounds = resolveLayerBounds(child);
+        return bounds ? [bounds] : [];
+      }));
+    case "image":
+      return undefined;
+  }
+}
+
+function unionRects(rects: Rect[]): Rect | undefined {
+  if (rects.length === 0) return undefined;
+
+  const minX = Math.min(...rects.map((rect) => rect.x));
+  const minY = Math.min(...rects.map((rect) => rect.y));
+  const maxX = Math.max(...rects.map((rect) => rect.x + rect.w));
+  const maxY = Math.max(...rects.map((rect) => rect.y + rect.h));
+
+  return { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
+}

editor/transform.ts

@@ -1,12 +1,17 @@
 import type { Rect, Vec2D } from "@core/geometry";
-import type { ArtboardId } from "@core/id";
+import type { ArtboardId, LayerId } from "@core/id";
 
 export type TransformHandle = "body" | "n" | "ne" | "e" | "se" | "s" | "sw" | "w" | "nw";
 
-export type TransformTarget = {
-  type: "artboard";
-  id: ArtboardId;
-};
+export type TransformTarget =
+  | {
+      type: "artboard";
+      id: ArtboardId;
+    }
+  | {
+      type: "layer";
+      id: LayerId;
+    };
 
 export type TransformSession = {
   target: TransformTarget;