Skip to content

Write HTML. Render video. Built for agents.

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

import React, { act } from "react";
import { createRoot } from "react-dom/client";
import { afterEach, describe, expect, it, vi, type Mock } from "vitest";
import { TIMELINE_ASSET_MIME, TIMELINE_BLOCK_MIME } from "../../utils/timelineAssetDrop";
import { usePlayerStore, type TimelineElement } from "../store/playerStore";
import { createTimelineRowGeometry } from "./timelineLayout";
import { resolveDropInsertRow, useTimelineAssetDrop } from "./timelineDragDrop";
import { getTimelineRowTop, TRACK_H } from "./timelineLayout";
import { configureTimelineTestViewport } from "./timelineTestViewport";

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

const ROW0_MID_Y = getTimelineRowTop(0) + TRACK_H / 2;

interface DropTransfer {
  types: string[];
  files: File[];
  dropEffect: DataTransfer["dropEffect"];
  getData: (type: string) => string;
}

function dragEvent(transfer: DropTransfer, clientX: number, clientY: number): React.DragEvent {
  return {
    clientX,
    clientY,
    dataTransfer: transfer,
    preventDefault: vi.fn(),
  } as unknown as React.DragEvent;
}

function assetTransfer(payload: string): DropTransfer {
  return {
    types: [TIMELINE_ASSET_MIME],
    files: [],
    dropEffect: "none",
    getData: (type) => (type === TIMELINE_ASSET_MIME ? payload : ""),
  };
}

// One far-off clip per lane, so a drop keeps its pointer time instead of an empty lane's 0.
const FAR_CLIPS: TimelineElement[] = Array.from({ length: 100 }, (_, track) => ({
  id: `far-${track}`,
  tag: "div",
  start: 900,
  duration: 1,
  track,
}));

function renderHarness(
  onAssetDrop: Mock,
  sessionEpoch = 1,
  options: { onBlockDrop?: Mock; strict?: boolean; elements?: TimelineElement[] } = {},
) {
  const tracks = Array.from({ length: 100 }, (_, index) => index);
  const geometry = createTimelineRowGeometry(
    tracks,
    tracks.map(() => 48),
  );
  const scroll = document.createElement("div");
  configureTimelineTestViewport(scroll, geometry.canvasHeight);
  document.body.append(scroll);
  const root = createRoot(document.createElement("div"));
  let api: ReturnType<typeof useTimelineAssetDrop> | null = null;

  function Probe({ epoch }: { epoch: number }) {
    api = useTimelineAssetDrop({
      scrollRef: { current: scroll },
      ppsRef: { current: 40 },
      trackOrderRef: { current: tracks },
      elementsRef: { current: options.elements ?? FAR_CLIPS },
      rowGeometryRef: { current: geometry },
      contentOrigin: 0,
      sessionEpoch: epoch,
      onAssetDrop,
      onBlockDrop: options.onBlockDrop,
    });
    return null;
  }

  const renderProbe = (epoch: number) =>
    root.render(
      options.strict ? (
        <React.StrictMode>
          <Probe epoch={epoch} />
        </React.StrictMode>
      ) : (
        <Probe epoch={epoch} />
      ),
    );
  act(() => renderProbe(sessionEpoch));
  return {
    scroll,
    root,
    get api() {
      if (!api) throw new Error("drop harness did not render");
      return api;
    },
    rerender(epoch: number) {
      act(() => renderProbe(epoch));
    },
  };
}

afterEach(() => {
  vi.restoreAllMocks();
  usePlayerStore.getState().reset();
  document.body.innerHTML = "";
});

describe("useTimelineAssetDrop", () => {
  it("edge-autoscrolls the sole timeline viewport while a supported asset is held", () => {
    let frame: FrameRequestCallback | null = null;
    vi.spyOn(globalThis, "requestAnimationFrame").mockImplementation((callback) => {
      frame = callback;
      return 1;
    });
    vi.spyOn(globalThis, "cancelAnimationFrame").mockImplementation(() => undefined);
    const view = renderHarness(vi.fn());

    act(() => view.api.handleAssetDragOver(dragEvent(assetTransfer("{}"), 790, 120)));
    expect(view.api.isDragOver).toBe(true);
    expect(frame).not.toBeNull();
    act(() => frame?.(0));
    expect(view.scroll.scrollLeft).toBeGreaterThan(0);
    expect(view.scroll.scrollTop).toBe(0);

    act(() => view.api.clearDropPreview());
    expect(view.api.isDragOver).toBe(false);
    act(() => view.root.unmount());
  });

  it("keeps the drop actor while moving between descendants", () => {
    const view = renderHarness(vi.fn());
    const parent = document.createElement("div");
    const child = document.createElement("div");
    parent.append(child);
    act(() => view.api.handleAssetDragOver(dragEvent(assetTransfer("{}"), 400, ROW0_MID_Y)));
    act(() =>
      view.api.handleAssetDragLeave({
        relatedTarget: child,
        currentTarget: parent,
      } as unknown as React.DragEvent),
    );
    expect(view.api.isDragOver).toBe(true);
    act(() => view.root.unmount());
  });

  it("drops once on a model row outside the mounted window and appends below the last row", () => {
    const onAssetDrop = vi.fn();
    const view = renderHarness(onAssetDrop);
    view.scroll.scrollTop = view.scroll.scrollHeight - view.scroll.clientHeight;
    const transfer = assetTransfer(JSON.stringify({ path: "/media/hero.mp4" }));

    act(() => {
      view.api.handleAssetDragOver(dragEvent(transfer, 400, 239));
      view.api.handleAssetDrop(dragEvent(transfer, 400, 239));
    });

    expect(onAssetDrop).toHaveBeenCalledTimes(1);
    // The appended lane is empty, so the drop starts at 0.
    expect(onAssetDrop).toHaveBeenCalledWith("/media/hero.mp4", { start: 0, track: 100 });
    expect(view.api.isDragOver).toBe(false);
    act(() => view.root.unmount());
  });

  it("places the drop at the pointer x, ignoring the playhead", () => {
    const onAssetDrop = vi.fn();
    const view = renderHarness(onAssetDrop);
    usePlayerStore.getState().setCurrentTime(50);
    const transfer = assetTransfer(JSON.stringify({ path: "/media/hero.mp4" }));

    act(() => {
      view.api.handleAssetDragOver(dragEvent(transfer, 80, ROW0_MID_Y));
      view.api.handleAssetDrop(dragEvent(transfer, 80, ROW0_MID_Y));
    });

    // pps=40, clientX=80 -> 2s, far from the 50s playhead: proves start tracks
    // the drop position, not usePlayerStore.currentTime.
    expect(onAssetDrop).toHaveBeenCalledWith("/media/hero.mp4", { start: 2, track: 0 });
    act(() => view.root.unmount());
  });

  it("ignores malformed payloads and clears the actor on project reset", () => {
    const onAssetDrop = vi.fn();
    const view = renderHarness(onAssetDrop, 1);
    const transfer = assetTransfer("not-json");

    act(() => view.api.handleAssetDragOver(dragEvent(transfer, 400, ROW0_MID_Y)));
    expect(view.api.isDragOver).toBe(true);
    view.rerender(2);
    expect(view.api.isDragOver).toBe(false);

    act(() => view.api.handleAssetDrop(dragEvent(transfer, 400, ROW0_MID_Y)));
    expect(onAssetDrop).not.toHaveBeenCalled();
    act(() => view.root.unmount());
  });

  it("falls through a malformed asset payload to a valid block payload", () => {
    const onAssetDrop = vi.fn();
    const onBlockDrop = vi.fn();
    const view = renderHarness(onAssetDrop, 1, { onBlockDrop });
    const transfer: DropTransfer = {
      types: [TIMELINE_ASSET_MIME, TIMELINE_BLOCK_MIME],
      files: [],
      dropEffect: "none",
      getData: (type) =>
        type === TIMELINE_ASSET_MIME
          ? "not-json"
          : type === TIMELINE_BLOCK_MIME
            ? JSON.stringify({ name: "title-card" })
            : "",
    };

    act(() => {
      view.api.handleAssetDragOver(dragEvent(transfer, 400, ROW0_MID_Y));
      view.api.handleAssetDrop(dragEvent(transfer, 400, ROW0_MID_Y));
    });

    expect(onAssetDrop).not.toHaveBeenCalled();
    // pps=40, clientX=400 -> 10s at the pointer.
    expect(onBlockDrop).toHaveBeenCalledExactlyOnceWith("title-card", { start: 10, track: 0 });
    act(() => view.root.unmount());
  });

  it("clears an escaped drag after StrictMode effect replay", () => {
    const view = renderHarness(vi.fn(), 1, { strict: true });
    act(() => view.api.handleAssetDragOver(dragEvent(assetTransfer("{}"), 400, ROW0_MID_Y)));
    expect(view.api.isDragOver).toBe(true);

    act(() => window.dispatchEvent(new Event("dragend")));
    expect(view.api.isDragOver).toBe(false);
    act(() => view.root.unmount());
  });

  it("previews the exact placement the drop commits, and clears it after", () => {
    const onAssetDrop = vi.fn();
    const view = renderHarness(onAssetDrop);
    const payload = JSON.stringify({ path: "assets/a.png" });

    act(() => view.api.handleAssetDragOver(dragEvent(assetTransfer(payload), 400, ROW0_MID_Y)));
    const preview = view.api.dropPreview;
    expect(preview).toEqual({ start: 10, track: 0 });

    act(() => view.api.handleAssetDrop(dragEvent(assetTransfer(payload), 400, ROW0_MID_Y)));
    expect(onAssetDrop).toHaveBeenCalledExactlyOnceWith("assets/a.png", preview);
    expect(view.api.dropPreview).toBeNull();
    act(() => view.root.unmount());
  });

  it("moves the preview with the pointer and drops it when the drag leaves", () => {
    const view = renderHarness(vi.fn());
    act(() => view.api.handleAssetDragOver(dragEvent(assetTransfer("{}"), 400, ROW0_MID_Y)));
    act(() => view.api.handleAssetDragOver(dragEvent(assetTransfer("{}"), 800, ROW0_MID_Y)));
    expect(view.api.dropPreview?.start).toBe(20);

    act(() =>
      view.api.handleAssetDragLeave({
        relatedTarget: null,
        currentTarget: document.body,
      } as unknown as React.DragEvent),
    );
    expect(view.api.dropPreview).toBeNull();
    act(() => view.root.unmount());
  });
});

describe("useTimelineAssetDrop start", () => {
  function dropAt(elements: TimelineElement[], clientX: number) {
    const onAssetDrop = vi.fn();
    const view = renderHarness(onAssetDrop, 1, { elements });
    const transfer = assetTransfer(JSON.stringify({ path: "assets/a.mp4" }));
    act(() => view.api.handleAssetDragOver(dragEvent(transfer, clientX, ROW0_MID_Y)));
    const preview = view.api.dropPreview;
    act(() => view.api.handleAssetDrop(dragEvent(transfer, clientX, ROW0_MID_Y)));
    act(() => view.root.unmount());
    return { preview, committed: onAssetDrop.mock.calls[0]?.[1] };
  }

  it("starts a drop on an empty timeline at 0, in the preview and the commit", () => {
    // pps=40, clientX=80 -> 2s at the pointer.
    const { preview, committed } = dropAt([], 80);
    expect(preview).toEqual({ start: 0, track: 0 });
    expect(committed).toEqual(preview);
  });

  it("starts a drop on an empty lane at 0 while other lanes hold clips", () => {
    const { committed } = dropAt([{ id: "c", tag: "div", start: 0, duration: 5, track: 1 }], 80);
    expect(committed).toEqual({ start: 0, track: 0 });
  });

  it("snaps a drop within TIMELINE_SNAP_PX of a clip edge onto that edge", () => {
    const lane: TimelineElement[] = [{ id: "c", tag: "div", start: 0, duration: 5, track: 0 }];
    // The clip ends at x=200; 6 px past it is 5.15s, inside the 8 px radius.
    const { preview, committed } = dropAt(lane, 206);
    expect(preview).toEqual({ start: 5, track: 0 });
    expect(committed).toEqual(preview);
    // 12 px past it is outside the radius and keeps the pointer time.
    expect(dropAt(lane, 212).committed).toEqual({ start: 5.3, track: 0 });
  });

  it("keeps the pointer time with the magnet off, and still starts an empty lane at 0", () => {
    usePlayerStore.getState().setTimelineSnapEnabled(false);
    try {
      const lane: TimelineElement[] = [{ id: "c", tag: "div", start: 0, duration: 5, track: 0 }];
      expect(dropAt(lane, 206).committed).toEqual({ start: 5.15, track: 0 });
      expect(dropAt([], 80).committed).toEqual({ start: 0, track: 0 });
    } finally {
      usePlayerStore.getState().setTimelineSnapEnabled(true);
    }
  });
});

describe("resolveDropInsertRow", () => {
  const rows = [TRACK_H, TRACK_H, TRACK_H];
  it("stays on the row at the boundary between two rows", () => {
    for (const dy of [-1, 0, 1]) {
      expect(resolveDropInsertRow(getTimelineRowTop(1, rows) + dy, rows, 3)).toBeNull();
    }
  });
  it("arms a new track above the first lane", () => {
    expect(resolveDropInsertRow(getTimelineRowTop(0, rows) - 4, rows, 3)).toBe(0);
  });
  it("stays on the lane when the pointer is over its middle", () => {
    expect(resolveDropInsertRow(getTimelineRowTop(1, rows) + TRACK_H / 2, rows, 3)).toBeNull();
  });
  it("leaves the area below the last lane to the append path", () => {
    expect(resolveDropInsertRow(getTimelineRowTop(2, rows) + TRACK_H + 4, rows, 3)).toBeNull();
  });
  it("never arms on an empty timeline", () => {
    expect(resolveDropInsertRow(80, [], 0)).toBeNull();
  });
});

describe("useTimelineAssetDrop new-track drops", () => {
  it("drops an asset released at the top edge of a row onto that row, with no new track", () => {
    const onAssetDrop = vi.fn();
    const view = renderHarness(onAssetDrop);
    const transfer = assetTransfer(JSON.stringify({ path: "assets/a.png" }));
    const y = getTimelineRowTop(1) + 1;

    act(() => view.api.handleAssetDragOver(dragEvent(transfer, 400, y)));
    expect(view.api.dropPreview).toEqual({ start: 10, track: 1 });
    act(() => view.api.handleAssetDrop(dragEvent(transfer, 400, y)));
    expect(onAssetDrop).toHaveBeenCalledWith("assets/a.png", { start: 10, track: 1 });
    act(() => view.root.unmount());
  });

  it("opens a new track for an asset released in the empty space above the first row", () => {
    const onAssetDrop = vi.fn();
    const view = renderHarness(onAssetDrop);
    const transfer = assetTransfer(JSON.stringify({ path: "assets/a.png" }));
    const y = getTimelineRowTop(0) - 4;

    act(() => view.api.handleAssetDragOver(dragEvent(transfer, 400, y)));
    act(() => view.api.handleAssetDrop(dragEvent(transfer, 400, y)));
    expect(onAssetDrop).toHaveBeenCalledWith(
      "assets/a.png",
      expect.objectContaining({
        start: 0,
        insertRow: 0,
        trackOrder: Array.from({ length: 100 }, (_, index) => index),
      }),
    );
    act(() => view.root.unmount());
  });

  it("does not ask a block drop to insert a track", () => {
    const onBlockDrop = vi.fn();
    const view = renderHarness(vi.fn(), 1, { onBlockDrop });
    const transfer: DropTransfer = {
      types: [TIMELINE_BLOCK_MIME],
      files: [],
      dropEffect: "none",
      getData: (type) => (type === TIMELINE_BLOCK_MIME ? JSON.stringify({ name: "b" }) : ""),
    };
    const y = getTimelineRowTop(1) + 1;
    act(() => {
      view.api.handleAssetDragOver(dragEvent(transfer, 400, y));
      view.api.handleAssetDrop(dragEvent(transfer, 400, y));
    });
    expect(onBlockDrop).toHaveBeenCalledWith("b", { start: 10, track: 1 });
    act(() => view.root.unmount());
  });
});