Skip to content

Write HTML. Render video. Built for agents.

19.2 KB
Raw Blame
// @vitest-environment happy-dom

import React, { act } from "react";
import { createRoot, type Root } from "react-dom/client";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { makeSelection } from "../../hooks/domSelectionTestHarness";
import { CANVAS_NUDGE_COMMIT_DEBOUNCE_MS } from "./domEditNudge";
import { __resetForTests } from "../../utils/canvasNudgeGate";
import { PreviewReadOnlyProvider } from "./previewReadOnlyContext";
import "./domEditOverlayTestMocks";
import { DomEditOverlay } from "./DomEditOverlay";
import { UNREADABLE_TRANSLATE } from "./plainTranslate";

(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;

const RECT = { left: 100, top: 100, width: 200, height: 100, editScaleX: 1, editScaleY: 1 };
const layout = vi.hoisted(() => ({
  group: [] as unknown[],
  hover: null as unknown,
  offCanvas: [] as unknown[],
  offCanvasElements: new Map<string, HTMLElement>(),
}));

const actions = vi.hoisted(() => ({ current: null as unknown }));
vi.mock("../../contexts/DomEditContext", async (importOriginal) => ({
  ...(await importOriginal<typeof import("../../contexts/DomEditContext")>()),
  useDomEditActionsContextOptional: () => actions.current,
}));
vi.mock("./useOffCanvasIndicators", () => ({
  useOffCanvasIndicators: () => ({
    offCanvasRects: layout.offCanvas,
    offCanvasElementsRef: { current: layout.offCanvasElements },
  }),
}));

vi.mock("./useDomEditOverlayRects", () => ({
  useDomEditOverlayRects: () => ({
    overlayRect: { left: 100, top: 100, width: 200, height: 100, editScaleX: 1, editScaleY: 1 },
    overlayRectRef: {
      current: { left: 100, top: 100, width: 200, height: 100, editScaleX: 1, editScaleY: 1 },
    },
    setOverlayRect: () => undefined,
    hoverRect: layout.hover,
    groupOverlayItems: layout.group,
    groupOverlayItemsRef: { current: layout.group },
    setGroupOverlayItems: () => undefined,
    childRects: [],
  }),
}));
const BOX = '[data-dom-edit-selection-box="true"]';
let root: Root;
let host: HTMLElement;

function textElement(id: string): HTMLElement {
  const element = document.createElement("h1");
  element.id = id;
  element.textContent = "Title";
  document.body.append(element);
  return element;
}

function fixture(
  overrides: Partial<React.ComponentProps<typeof DomEditOverlay>> = {},
  readOnly = false,
) {
  const spies = {
    onCanvasMouseDown: vi.fn(),
    onSelectionChange: vi.fn(),
    onManualDragStart: vi.fn(),
    onBlockedMove: vi.fn(),
    onPathOffsetCommit: vi.fn(),
    onGroupPathOffsetCommit: vi.fn(),
    onBoxSizeCommit: vi.fn(),
    onRotationCommit: vi.fn(),
    onStyleCommit: vi.fn(),
    onDeleteSelection: vi.fn(),
    onApplyZIndex: vi.fn(),
    onMarqueeSelect: vi.fn(),
    onTextEditingChange: vi.fn(),
  };
  const selection = makeSelection("Title", textElement("title"));
  selection.capabilities.canApplyManualRotation = true;
  selection.textFields = [{ key: "text", label: "Text", value: "Title" }] as never;
  const props = {
    iframeRef: { current: document.createElement("iframe") },
    activeCompositionPath: null,
    selection,
    hoverSelection: null,
    onCanvasPointerMove: () => Promise.resolve(selection),
    onCanvasPointerLeave: () => undefined,
    ...spies,
    ...overrides,
  };
  host = document.createElement("div");
  document.body.append(host);
  root = createRoot(host);
  act(() =>
    root.render(
      <PreviewReadOnlyProvider readOnly={readOnly}>
        <DomEditOverlay {...props} />
      </PreviewReadOnlyProvider>,
    ),
  );
  return { spies, selection, overlay: host.firstElementChild as HTMLElement };
}

const fire = (target: Element, type: string, init: MouseEventInit = {}) => {
  const buttons = type === "pointerdown" || type === "pointermove" ? 1 : 0;
  const event = new MouseEvent(type, {
    bubbles: true,
    cancelable: true,
    button: 0,
    buttons,
    ...init,
  });
  act(() => {
    target.dispatchEvent(event);
  });
  return event;
};

const pressEnter = (overlay: HTMLElement) =>
  act(() => {
    overlay.dispatchEvent(
      new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }),
    );
  });

const clickBox = (overlay: HTMLElement) => {
  const box = overlay.querySelector(BOX)!;
  for (const type of ["pointerdown", "pointerup", "click"]) fire(box, type);
};

const enterOn = (target: Element) =>
  act(() => {
    target.dispatchEvent(
      new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }),
    );
  });

const rightClick = async (overlay: HTMLElement) => {
  await act(async () => {
    overlay.dispatchEvent(
      new MouseEvent("contextmenu", { bubbles: true, cancelable: true, clientX: 5, clientY: 5 }),
    );
  });
};

beforeEach(() => {
  vi.useFakeTimers();
  __resetForTests();
  HTMLElement.prototype.setPointerCapture = () => undefined;
});

afterEach(() => {
  act(() => root.unmount());
  actions.current = null;
  document.body.innerHTML = "";
  layout.group = [];
  layout.hover = null;
  layout.offCanvas = [];
  layout.offCanvasElements.clear();
  vi.useRealTimers();
});

describe("DomEditOverlay with the preview read-only", () => {
  it("control: with the flag off a press on the box starts a move", () => {
    const { spies, overlay } = fixture();
    fire(overlay.querySelector(BOX)!, "pointerdown");
    expect(spies.onManualDragStart).toHaveBeenCalledTimes(1);
  });

  it("refuses to start a move from the selection box", () => {
    const { spies, overlay } = fixture({}, true);
    const box = overlay.querySelector(BOX)!;
    fire(box, "pointerdown");
    fire(box, "pointermove", { clientX: 40 });
    fire(box, "pointerup");
    expect(spies.onManualDragStart).not.toHaveBeenCalled();
    expect(spies.onBlockedMove).not.toHaveBeenCalled();
    expect(spies.onPathOffsetCommit).not.toHaveBeenCalled();
  });

  it("offers no resize dots, and none can start a resize", () => {
    const off = fixture();
    expect(off.overlay.querySelectorAll("div.h-4.w-4")).toHaveLength(4);
    act(() => root.unmount());
    document.body.innerHTML = "";
    const { spies, overlay } = fixture({}, true);
    expect(overlay.querySelectorAll("div.h-4.w-4")).toHaveLength(0);
    expect(spies.onBoxSizeCommit).not.toHaveBeenCalled();
  });

  it("offers no rotate handle", () => {
    const off = fixture();
    expect(off.overlay.querySelector('[aria-label="Rotate selection"]')).not.toBeNull();
    act(() => root.unmount());
    document.body.innerHTML = "";
    const { spies, overlay } = fixture({}, true);
    expect(overlay.querySelector('[aria-label="Rotate selection"]')).toBeNull();
    expect(spies.onRotationCommit).not.toHaveBeenCalled();
  });

  it("offers no crop handles, so clip-path is never committed", () => {
    const off = fixture();
    expect(off.overlay.querySelector("[data-dom-edit-crop-frame]")).not.toBeNull();
    act(() => root.unmount());
    document.body.innerHTML = "";
    const { spies, overlay } = fixture({}, true);
    expect(overlay.querySelector("[data-dom-edit-crop-frame]")).toBeNull();
    expect(spies.onStyleCommit).not.toHaveBeenCalled();
  });

  it("does not drag a multi-selection", () => {
    const members = ["a", "b"].map((id) => {
      const selection = makeSelection(id, textElement(id));
      return { key: id, selection, element: selection.element, rect: RECT };
    });
    layout.group = members;
    const { spies, overlay } = fixture(
      {
        selection: null,
        groupSelections: members.map((m) => m.selection),
      },
      true,
    );
    fire(overlay.querySelector(BOX)!, "pointerdown");
    expect(spies.onManualDragStart).not.toHaveBeenCalled();
    expect(spies.onGroupPathOffsetCommit).not.toHaveBeenCalled();
  });

  const nudge = () => {
    const event = new KeyboardEvent("keydown", {
      key: "ArrowRight",
      bubbles: true,
      cancelable: true,
    });
    act(() => {
      window.dispatchEvent(event);
      vi.advanceTimersByTime(CANVAS_NUDGE_COMMIT_DEBOUNCE_MS + 10);
    });
    return event;
  };

  it("control: with the flag off an arrow key nudges", () => {
    const { spies } = fixture();
    expect(nudge().defaultPrevented).toBe(true);
    expect(spies.onPathOffsetCommit).toHaveBeenCalledTimes(1);
  });

  it("neither nudges on an arrow key nor swallows it", () => {
    const { spies } = fixture({}, true);
    expect(nudge().defaultPrevented).toBe(false);
    expect(spies.onPathOffsetCommit).not.toHaveBeenCalled();
  });

  it("control: with the flag off Enter opens the text for editing", () => {
    const { selection, overlay } = fixture();
    pressEnter(overlay);
    expect(selection.element.hasAttribute("contenteditable")).toBe(true);
  });

  it("does not open text for editing on Enter", () => {
    const { selection, overlay } = fixture({}, true);
    pressEnter(overlay);
    expect(selection.element.hasAttribute("contenteditable")).toBe(false);
  });

  it("control: with the flag off right-click offers delete and z-order", async () => {
    const { overlay } = fixture();
    await rightClick(overlay);
    expect(document.body.textContent).toContain("Delete");
  });

  it("offers no delete or z-order on right-click when read-only", async () => {
    // Same fixture as the control test above (a real, already-selected element) so the
    // context menu actually opens; `selection: null` here would close it via
    // useCanvasContextMenuState's own deselect effect, before read-only ever mattered.
    const { spies, overlay } = fixture({}, true);
    await rightClick(overlay);
    expect(document.body.textContent).not.toContain("Delete");
    expect(spies.onDeleteSelection).not.toHaveBeenCalled();
    expect(spies.onApplyZIndex).not.toHaveBeenCalled();
  });

  it("still selects and reports to the host on right-click of an unselected element", async () => {
    const { spies, overlay } = fixture({ selection: null }, true);
    await rightClick(overlay);
    expect(spies.onSelectionChange).toHaveBeenCalledTimes(1);
  });

  it("still selects and reports to the host on a click", () => {
    const { spies, overlay } = fixture({ selection: null }, true);
    fire(overlay, "mousedown");
    expect(spies.onCanvasMouseDown).toHaveBeenCalledTimes(1);
  });

  it("still selects on a click of the selection box", () => {
    const { spies, overlay } = fixture({}, true);
    fire(overlay.querySelector(BOX)!, "click");
    expect(spies.onCanvasMouseDown).toHaveBeenCalledTimes(1);
  });
});

describe("DomEditOverlay with canvasInput host", () => {
  const HOST = { canvasInput: "host" } as const;

  it("lets presses through its root, and the overlay default keeps them", () => {
    expect(fixture().overlay.className).toContain("pointer-events-auto");
    act(() => root.unmount());
    expect(fixture(HOST).overlay.className).toContain("pointer-events-none");
  });

  it("draws the hover box for the selection the host hovers, and none without one", () => {
    layout.hover = RECT;
    const hovered = (props = {}) => {
      const { overlay } = fixture(props);
      const box = overlay.querySelector('[data-dom-edit-hover-box="true"]');
      act(() => root.unmount());
      return box;
    };
    const selection = makeSelection("Hover", textElement("hover"));
    expect(hovered({ hoverSelection: selection })).not.toBeNull();
    expect(hovered({ ...HOST, hoverSelection: selection })).not.toBeNull();
    expect(hovered({ ...HOST, hoverSelection: null })).toBeNull();
  });

  it("starts no marquee and makes no selection from a press on empty canvas", () => {
    const off = fixture({ selection: null });
    fire(off.overlay, "pointerdown");
    fire(off.overlay, "pointerup");
    expect(off.spies.onMarqueeSelect).toHaveBeenCalledWith([], false);
    act(() => root.unmount());
    const { spies, overlay } = fixture({ ...HOST, selection: null });
    fire(overlay, "pointerdown");
    fire(overlay, "mousedown");
    fire(overlay, "pointerup");
    expect(spies.onMarqueeSelect).not.toHaveBeenCalled();
    expect(spies.onCanvasMouseDown).not.toHaveBeenCalled();
  });

  it("opens no context menu and selects nothing on right-click", async () => {
    const { spies, overlay } = fixture({ ...HOST, selection: null });
    await rightClick(overlay);
    expect(spies.onSelectionChange).not.toHaveBeenCalled();
    act(() => root.unmount());
    await rightClick(fixture(HOST).overlay);
    expect(document.body.textContent).not.toContain("Delete");
  });

  it("does not re-select on a click of the selection box", () => {
    const off = fixture();
    clickBox(off.overlay);
    expect(off.spies.onCanvasMouseDown).toHaveBeenCalledTimes(1);
    act(() => root.unmount());
    const { spies, overlay } = fixture(HOST);
    clickBox(overlay);
    fire(overlay.querySelector(BOX)!, "click");
    expect(spies.onCanvasMouseDown).not.toHaveBeenCalled();
  });

  it("offers no off-canvas indicator to press, so nothing re-selects from one", async () => {
    const MARK = '[aria-label="Select off-canvas element stray"]';
    const offCanvas = (props = {}) => {
      layout.offCanvasElements.set("stray", textElement("stray"));
      layout.offCanvas = [{ key: "stray", left: 820, top: 10, width: 120, height: 40 }];
      return fixture(props);
    };
    const off = offCanvas();
    fire(off.overlay.querySelector(MARK)!, "click");
    await vi.waitFor(() => expect(off.spies.onSelectionChange).toHaveBeenCalledTimes(1));
    act(() => root.unmount());
    const { spies, overlay } = offCanvas(HOST);
    expect(overlay.querySelector(MARK)).toBeNull();
    expect(spies.onSelectionChange).not.toHaveBeenCalled();
  });

  it("reports each selection-box click to the host once, by either route", () => {
    const cases = [
      { props: {}, movable: true, reselects: 1 },
      { props: HOST, movable: true, reselects: 0 },
      { props: HOST, movable: false, reselects: 0 },
    ];
    for (const { props, movable, reselects } of cases) {
      const onSelectionBoxClick = vi.fn();
      const { spies, selection, overlay } = fixture({ ...props, onSelectionBoxClick });
      selection.capabilities.canApplyManualOffset = movable;
      clickBox(overlay);
      expect(onSelectionBoxClick).toHaveBeenCalledTimes(1);
      expect(onSelectionBoxClick).toHaveBeenCalledWith(expect.anything(), selection);
      expect(spies.onCanvasMouseDown).toHaveBeenCalledTimes(reselects);
      act(() => root.unmount());
    }
  });

  it("does not report a press off the box, or a click on a group's box", () => {
    const onSelectionBoxClick = vi.fn();
    const off = fixture({ onSelectionBoxClick, onMarqueeSelect: undefined });
    for (const type of ["pointerdown", "mousedown", "pointerup", "click"]) fire(off.overlay, type);
    expect(off.spies.onCanvasMouseDown).toHaveBeenCalledTimes(1);
    act(() => root.unmount());
    const members = ["a", "b"].map((id) => {
      const selection = makeSelection(id, textElement(id));
      return { key: id, selection, element: selection.element, rect: RECT };
    });
    members[1].selection.capabilities.canApplyManualOffset = false;
    layout.group = members;
    const { spies, overlay } = fixture({
      onSelectionBoxClick,
      selection: members[0].selection,
      groupSelections: members.map((m) => m.selection),
    });
    clickBox(overlay);
    expect(spies.onCanvasMouseDown).toHaveBeenCalledTimes(1);
    expect(onSelectionBoxClick).not.toHaveBeenCalled();
  });

  it("reports the first box click after a handle resize", () => {
    const onSelectionBoxClick = vi.fn();
    const { selection, overlay } = fixture({ ...HOST, onSelectionBoxClick });
    for (const type of ["pointerdown", "pointerup", "click"]) {
      fire(overlay.querySelector("div.h-4.w-4")!, type);
    }
    selection.capabilities.canApplyManualOffset = false;
    clickBox(overlay);
    expect(onSelectionBoxClick).toHaveBeenCalledTimes(1);
  });

  it("opens the text on Enter when nothing else has focus, not from a focused field", () => {
    const off = fixture();
    enterOn(document.body);
    expect(off.selection.element.hasAttribute("contenteditable")).toBe(false);
    act(() => root.unmount());
    const { spies, selection } = fixture(HOST);
    const field = document.createElement("input");
    document.body.append(field);
    enterOn(field);
    expect(selection.element.hasAttribute("contenteditable")).toBe(false);
    enterOn(document.body);
    expect(selection.element.hasAttribute("contenteditable")).toBe(true);
    expect(spies.onTextEditingChange.mock.calls).toEqual([[true]]);
  });

  it("keeps the handles working: drag, resize dots and rotate", () => {
    const { spies, overlay } = fixture(HOST);
    fire(overlay.querySelector(BOX)!, "pointerdown");
    expect(spies.onManualDragStart).toHaveBeenCalledTimes(1);
    fire(overlay.querySelector(BOX)!, "pointerup");
    expect(overlay.querySelectorAll("div.h-4.w-4")).toHaveLength(4);
    const rotate = overlay.querySelector('[aria-label="Rotate selection"]')!;
    fire(rotate, "pointerdown", { clientX: 200, clientY: 250 });
    fire(rotate, "pointermove", { clientX: 300, clientY: 150 });
    fire(rotate, "pointerup", { clientX: 300, clientY: 150 });
    expect(spies.onRotationCommit).toHaveBeenCalledTimes(1);
  });
});

describe("DomEditOverlay onTextEditingChange", () => {
  it("reports true when the caret goes live and false when the edit ends", () => {
    const { spies, selection, overlay } = fixture();
    expect(spies.onTextEditingChange).not.toHaveBeenCalled();
    pressEnter(overlay);
    expect(spies.onTextEditingChange.mock.calls).toEqual([[true]]);
    act(() => {
      selection.element.dispatchEvent(
        new KeyboardEvent("keydown", { key: "Escape", bubbles: true, cancelable: true }),
      );
    });
    expect(spies.onTextEditingChange.mock.calls).toEqual([[true], [false]]);
  });

  it("saves the typed words and reports false when the overlay unmounts mid-edit", () => {
    const handleDomRichTextCommit = vi.fn();
    actions.current = { handleDomRichTextCommit };
    const { spies, selection, overlay } = fixture();
    pressEnter(overlay);
    selection.element.textContent = "Typed";
    act(() => root.unmount());
    expect(handleDomRichTextCommit).toHaveBeenCalledWith({
      element: selection.element,
      html: "Typed",
      previousHtml: "Title",
    });
    expect(spies.onTextEditingChange.mock.calls).toEqual([[true], [false]]);
  });
});

describe("DomEditOverlay on a layer whose translate Studio can't read", () => {
  it("refuses a drag and an arrow nudge out loud, and commits nothing", () => {
    const { spies, overlay, selection } = fixture();
    selection.element.style.setProperty("translate", "abs(10% - 50px) 0px");
    fire(overlay.querySelector(BOX)!, "pointerdown");
    const presses = [false, true, true].map(
      (repeat) =>
        new KeyboardEvent("keydown", {
          key: "ArrowRight",
          bubbles: true,
          cancelable: true,
          repeat,
        }),
    );
    act(() => {
      for (const press of presses) window.dispatchEvent(press);
      vi.advanceTimersByTime(CANVAS_NUDGE_COMMIT_DEBOUNCE_MS + 10);
    });
    // One toast for the drag and one for the whole held arrow, whose every press is swallowed.
    expect(spies.onBlockedMove.mock.calls).toEqual([
      [selection, UNREADABLE_TRANSLATE],
      [selection, UNREADABLE_TRANSLATE],
    ]);
    expect(presses.map((press) => press.defaultPrevented)).toEqual([true, true, true]);
    expect(spies.onPathOffsetCommit).not.toHaveBeenCalled();
    expect(selection.element.style.getPropertyValue("translate")).toBe("abs(10% - 50px) 0px");
  });
});