image-studio/input/document-geometry.ts

import type { Rect, Size, Vec2D } from "@core/geometry";
import type { InputArtboardId, InputDocument, InputLayer, InputLayerId } from "./read-model";

export type InputViewportState = {
  center: Vec2D;
  zoom: number;
  rotation?: number;
  size: Size;
};

export type InputSelectionState = {
  artboardId?: InputArtboardId;
  layerIds: InputLayerId[];
};

export type InputTransformTarget =
  | { type: "artboard"; id: InputArtboardId }
  | { type: "layer"; id: InputLayerId };

export function selectedTransformTarget(_document: InputDocument, selection: InputSelectionState): InputTransformTarget | 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;
}

export function resolveTransformTargetBounds(document: InputDocument, target: InputTransformTarget): 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(document, layer) : undefined;
    }
  }
}

export function viewportPointToDocumentPoint(point: Vec2D, viewport: InputViewportState): Vec2D {
  return {
    x: viewport.center.x + (point.x - viewport.size.w / 2) / viewport.zoom,
    y: viewport.center.y + (point.y - viewport.size.h / 2) / viewport.zoom,
  };
}

export function documentRectToViewportRect(rect: Rect, viewport: InputViewportState): Rect {
  return {
    x: viewport.size.w / 2 + (rect.x - viewport.center.x) * viewport.zoom,
    y: viewport.size.h / 2 + (rect.y - viewport.center.y) * viewport.zoom,
    w: rect.w * viewport.zoom,
    h: rect.h * viewport.zoom,
  };
}

function findLayer(document: InputDocument, layerId: InputLayerId): InputLayer | undefined {
  for (const artboard of document.artboards) {
    const layer = findLayerInTree(artboard.layers, layerId);
    if (layer) return layer;
  }

  return undefined;
}

function findLayerInTree(layers: readonly InputLayer[], layerId: InputLayerId): InputLayer | 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(document: InputDocument, layer: InputLayer): Rect | undefined {
  switch (layer.type) {
    case "group":
      return unionRects(layer.children.flatMap((child) => {
        const bounds = resolveLayerBounds(document, child);
        return bounds ? [bounds] : [];
      }));
    case "image":
    case "raster": {
      const asset = document.assets.find((candidate) => candidate.id === layer.assetId);
      if (!asset) return undefined;

      return {
        x: layer.transform.position.x,
        y: layer.transform.position.y,
        w: asset.intrinsicSize.w * layer.transform.scale.x,
        h: asset.intrinsicSize.h * layer.transform.scale.y,
      };
    }
  }
}

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 };
}