@agent-native/core-corpus 0.213.1 → 0.216.0

package/corpus/templates/slides-2/app/components/slides-2-editor/editor-export-errors.ts

@@ -0,0 +1,60 @@
+import { isSourceRuntimeExportError } from "@shared/source-runtime-export";
+
+import {
+  getEditorActionErrorCode,
+  getEditorActionErrorTranslationKey,
+  type EditorActionErrorTranslationKey,
+} from "./editor-action-errors";
+import {
+  getSandboxRenderErrorKey,
+  type SandboxRenderErrorKey,
+} from "./sandbox-render-errors";
+
+const EXPORT_ACTION_ERROR_TRANSLATIONS = {
+  empty_deck: "editorExport.exportFailed",
+  export_revision_stale: "editorErrors.deckChanged",
+  pptx_image_unavailable: "editorExport.pptxImageUnavailable",
+} as const;
+const EDITOR_EXPORT_ACTION_ERROR_CODES = new Set([
+  "deck_not_found",
+  "not_authenticated",
+  "slide_not_found",
+  "slide_source_missing",
+  "slide_source_conflict",
+  "slide_source_integrity_error",
+  "slide_source_owner_required",
+  "invalid_deck_data",
+  "invalid_slide_data",
+  "invalid_deck_slide_order",
+  "deck_revision_conflict",
+  "deck_write_conflict",
+]);
+
+export type EditorExportErrorTranslationKey =
+  | EditorActionErrorTranslationKey
+  | SandboxRenderErrorKey
+  | "editorExport.sourceRuntimeExportUnavailable"
+  | "editorExport.pptxImageUnavailable";
+
+export function getEditorExportErrorTranslationKey(
+  error: unknown,
+): EditorExportErrorTranslationKey {
+  const sandboxErrorKey = getSandboxRenderErrorKey(error);
+  if (sandboxErrorKey) return sandboxErrorKey;
+  if (isSourceRuntimeExportError(error)) {
+    return "editorExport.sourceRuntimeExportUnavailable";
+  }
+
+  const errorCode = getEditorActionErrorCode(error);
+  if (errorCode && errorCode in EXPORT_ACTION_ERROR_TRANSLATIONS) {
+    return EXPORT_ACTION_ERROR_TRANSLATIONS[
+      errorCode as keyof typeof EXPORT_ACTION_ERROR_TRANSLATIONS
+    ];
+  }
+  if (errorCode && EDITOR_EXPORT_ACTION_ERROR_CODES.has(errorCode)) {
+    const actionErrorKey = getEditorActionErrorTranslationKey(error);
+    if (actionErrorKey) return actionErrorKey;
+  }
+
+  return "editorExport.exportFailed";
+}

package/corpus/templates/slides-2/app/components/slides-2-editor/geometry.ts

@@ -0,0 +1,275 @@
+export type Point = { x: number; y: number };
+
+export type Rect = Point & { width: number; height: number };
+
+export const SLIDES_2_BOUNDS: Rect = {
+  x: 0,
+  y: 0,
+  width: 1920,
+  height: 1080,
+};
+
+export type Alignment =
+  | "left"
+  | "center"
+  | "right"
+  | "top"
+  | "middle"
+  | "bottom";
+
+export type Guide = {
+  axis: "x" | "y";
+  position: number;
+  start: number;
+  end: number;
+};
+
+export type ResizeHandle = "n" | "ne" | "e" | "se" | "s" | "sw" | "w" | "nw";
+
+export function unionRects(rects: Rect[]): Rect | null {
+  if (!rects.length) return null;
+  const x = Math.min(...rects.map((rect) => rect.x));
+  const y = Math.min(...rects.map((rect) => rect.y));
+  return {
+    x,
+    y,
+    width: Math.max(...rects.map((rect) => rect.x + rect.width)) - x,
+    height: Math.max(...rects.map((rect) => rect.y + rect.height)) - y,
+  };
+}
+
+export function constrainMoveDelta(delta: Point, lockAxis: boolean): Point {
+  if (!lockAxis) return delta;
+  return Math.abs(delta.x) >= Math.abs(delta.y)
+    ? { x: delta.x, y: 0 }
+    : { x: 0, y: delta.y };
+}
+
+export function snapRotationTo15Degrees(
+  rotation: number,
+  enabled: boolean,
+): number {
+  return enabled ? Math.round(rotation / 15) * 15 : rotation;
+}
+
+function anchors(rect: Rect, axis: "x" | "y"): number[] {
+  const size = axis === "x" ? rect.width : rect.height;
+  return [rect[axis], rect[axis] + size / 2, rect[axis] + size];
+}
+
+function nearestSnap(
+  rect: Rect,
+  targets: Rect[],
+  axis: "x" | "y",
+  threshold: number,
+) {
+  let best: { correction: number; position: number } | null = null;
+  for (const target of targets) {
+    for (const position of anchors(target, axis)) {
+      for (const anchor of anchors(rect, axis)) {
+        const correction = position - anchor;
+        const distance = Math.abs(correction);
+        if (distance > threshold) continue;
+        if (
+          !best ||
+          distance < Math.abs(best.correction) ||
+          (distance === Math.abs(best.correction) &&
+            correction < best.correction) ||
+          (correction === best.correction && position < best.position)
+        ) {
+          best = { correction, position };
+        }
+      }
+    }
+  }
+  return best;
+}
+
+export function snapMove(
+  rect: Rect,
+  delta: Point,
+  targets: Rect[],
+  threshold: number,
+): { delta: Point; guides: Guide[] } {
+  const moved = { ...rect, x: rect.x + delta.x, y: rect.y + delta.y };
+  const xSnap = nearestSnap(moved, targets, "x", threshold);
+  const ySnap = nearestSnap(moved, targets, "y", threshold);
+  const snappedDelta = {
+    x: delta.x + (xSnap?.correction ?? 0),
+    y: delta.y + (ySnap?.correction ?? 0),
+  };
+  const snapped = {
+    ...rect,
+    x: rect.x + snappedDelta.x,
+    y: rect.y + snappedDelta.y,
+  };
+  const guides: Guide[] = [];
+  for (const axis of ["x", "y"] as const) {
+    const snap = axis === "x" ? xSnap : ySnap;
+    if (!snap) continue;
+    const aligned = targets.filter((target) =>
+      anchors(target, axis).some(
+        (anchor) => Math.abs(anchor - snap.position) < 0.000001,
+      ),
+    );
+    const bounds = unionRects([snapped, ...aligned]);
+    if (!bounds) continue;
+    guides.push({
+      axis,
+      position: snap.position,
+      start: axis === "x" ? bounds.y : bounds.x,
+      end: axis === "x" ? bounds.y + bounds.height : bounds.x + bounds.width,
+    });
+  }
+  return { delta: snappedDelta, guides };
+}
+
+export function alignRects(
+  rects: Rect[],
+  alignment: Alignment,
+  bounds?: Rect,
+): Point[] {
+  const target = bounds ?? unionRects(rects);
+  if (!target) return [];
+  return rects.map((rect) => {
+    switch (alignment) {
+      case "left":
+        return { x: target.x - rect.x, y: 0 };
+      case "center":
+        return {
+          x: target.x + target.width / 2 - rect.x - rect.width / 2,
+          y: 0,
+        };
+      case "right":
+        return { x: target.x + target.width - rect.x - rect.width, y: 0 };
+      case "top":
+        return { x: 0, y: target.y - rect.y };
+      case "middle":
+        return {
+          x: 0,
+          y: target.y + target.height / 2 - rect.y - rect.height / 2,
+        };
+      default:
+        return { x: 0, y: target.y + target.height - rect.y - rect.height };
+    }
+  });
+}
+
+export function distributeRects(rects: Rect[], axis: "x" | "y"): Point[] {
+  const deltas = rects.map(() => ({ x: 0, y: 0 }));
+  if (rects.length < 3) return deltas;
+  const size = axis === "x" ? "width" : "height";
+  const sorted = rects
+    .map((rect, index) => ({ rect, index }))
+    .sort((a, b) => a.rect[axis] - b.rect[axis] || a.index - b.index);
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  const totalSize = rects.reduce((sum, rect) => sum + rect[size], 0);
+  const gap =
+    (last.rect[axis] + last.rect[size] - first.rect[axis] - totalSize) /
+    (rects.length - 1);
+  let position = first.rect[axis];
+  for (const { rect, index } of sorted) {
+    deltas[index][axis] = position - rect[axis];
+    position += rect[size] + gap;
+  }
+  return deltas;
+}
+
+export function solveResizeDimensions(
+  size: Pick<Rect, "width" | "height">,
+  basis: { a: number; b: number; c: number; d: number },
+  delta: Point,
+): Pick<Rect, "width" | "height"> {
+  const { a, b, c, d } = basis;
+  const determinant = a * d - b * c;
+  const magnitude = Math.hypot(a, b) * Math.hypot(c, d);
+  // Nearly parallel dimension vectors amplify small pointer deltas into large distortions.
+  if (Math.abs(determinant) > magnitude * 0.1) {
+    const width = size.width + (d * delta.x - c * delta.y) / determinant;
+    const height = size.height + (a * delta.y - b * delta.x) / determinant;
+    if (
+      Number.isFinite(width) &&
+      Number.isFinite(height) &&
+      width >= 8 &&
+      height >= 8
+    )
+      return { width, height };
+  }
+  const direction = {
+    x: a * size.width + c * size.height,
+    y: b * size.width + d * size.height,
+  };
+  const lengthSquared = direction.x ** 2 + direction.y ** 2;
+  const requestedScale =
+    lengthSquared > 0
+      ? 1 + (direction.x * delta.x + direction.y * delta.y) / lengthSquared
+      : 1;
+  const scale = Math.max(8 / size.width, 8 / size.height, requestedScale);
+  return { width: size.width * scale, height: size.height * scale };
+}
+
+export function resizeRect(
+  rect: Rect,
+  handle: ResizeHandle,
+  delta: Point,
+  lockAspect = false,
+): Rect {
+  const west = handle.includes("w");
+  const east = handle.includes("e");
+  const north = handle.includes("n");
+  const south = handle.includes("s");
+  const horizontal = west || east;
+  const vertical = north || south;
+  const requestedWidth = rect.width + (west ? -delta.x : east ? delta.x : 0);
+  const requestedHeight =
+    rect.height + (north ? -delta.y : south ? delta.y : 0);
+  let width = Math.max(8, requestedWidth);
+  let height = Math.max(8, requestedHeight);
+  if (lockAspect && rect.width > 0 && rect.height > 0) {
+    const widthScale = requestedWidth / rect.width;
+    const heightScale = requestedHeight / rect.height;
+    const scale = Math.max(
+      8 / rect.width,
+      8 / rect.height,
+      horizontal &&
+        (!vertical || Math.abs(widthScale - 1) >= Math.abs(heightScale - 1))
+        ? widthScale
+        : heightScale,
+    );
+    width = rect.width * scale;
+    height = rect.height * scale;
+  }
+  return {
+    x: west
+      ? rect.x + rect.width - width
+      : horizontal
+        ? rect.x
+        : rect.x + (rect.width - width) / 2,
+    y: north
+      ? rect.y + rect.height - height
+      : vertical
+        ? rect.y
+        : rect.y + (rect.height - height) / 2,
+    width,
+    height,
+  };
+}
+
+export function rectsIntersect(a: Rect, b: Rect): boolean {
+  return (
+    a.x < b.x + b.width &&
+    a.x + a.width > b.x &&
+    a.y < b.y + b.height &&
+    a.y + a.height > b.y
+  );
+}
+
+export function rectContains(outer: Rect, inner: Rect): boolean {
+  return (
+    inner.x >= outer.x &&
+    inner.y >= outer.y &&
+    inner.x + inner.width <= outer.x + outer.width &&
+    inner.y + inner.height <= outer.y + outer.height
+  );
+}

package/corpus/templates/slides-2/app/components/slides-2-editor/image-crop-style.ts

@@ -0,0 +1,82 @@
+import type {
+  Slides2ImageCropRect,
+  Slides2ImageCropResult,
+} from "./Slides2ImageCropControls";
+
+export type ImageCropStyleEdit = {
+  key: "objectFit" | "objectPosition" | "objectViewBox";
+  value: string | null;
+};
+
+export function imageCropStyleEdits(
+  result: Slides2ImageCropResult,
+): ImageCropStyleEdit[] {
+  return [
+    { key: "objectFit", value: result.fit },
+    { key: "objectPosition", value: "50% 50%" },
+    {
+      key: "objectViewBox",
+      value:
+        result.fit === "cover" ? cropRectToObjectViewBox(result.rect) : null,
+    },
+  ];
+}
+
+export function cropRectToObjectViewBox(rect: Slides2ImageCropRect): string {
+  const top = round2(rect.y);
+  const left = round2(rect.x);
+  const right = round2(100 - rect.x - rect.width);
+  const bottom = round2(100 - rect.y - rect.height);
+  return `inset(${top}% ${right}% ${bottom}% ${left}%)`;
+}
+
+export function objectViewBoxToCropRect(
+  value: string | undefined,
+): Slides2ImageCropRect | null {
+  const match = value?.trim().match(/^inset\(([^)]+)\)$/i);
+  if (!match?.[1]) return null;
+
+  const values = match[1].trim().split(/\s+/).map(parsePercent);
+  if (values.some((part) => part === null)) return null;
+
+  let top: number;
+  let right: number;
+  let bottom: number;
+  let left: number;
+  if (values.length === 1) {
+    top = right = bottom = left = values[0]!;
+  } else if (values.length === 2) {
+    top = bottom = values[0]!;
+    right = left = values[1]!;
+  } else if (values.length === 3) {
+    top = values[0]!;
+    right = left = values[1]!;
+    bottom = values[2]!;
+  } else if (values.length === 4) {
+    [top, right, bottom, left] = values as [number, number, number, number];
+  } else {
+    return null;
+  }
+
+  const width = 100 - left - right;
+  const height = 100 - top - bottom;
+  if (
+    [top, right, bottom, left].some((part) => part < 0 || part > 100) ||
+    width <= 0 ||
+    height <= 0
+  ) {
+    return null;
+  }
+  return { x: left, y: top, width, height };
+}
+
+function parsePercent(value: string): number | null {
+  const match = value.match(/^(-?\d+(?:\.\d+)?)%$/);
+  if (!match?.[1]) return null;
+  const parsed = Number(match[1]);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function round2(value: number): number {
+  return Math.round(value * 100) / 100;
+}