sailfork / t3code-github / packages/ client-runtime/ src/ device/ duoViewer.test.ts

import { afterEach, expect, it, vi } from "vite-plus/test";
import type { Scene, PerspectiveCamera, Box3, Quaternion } from "three";

const gpu = vi.hoisted(() => ({
  instances: [] as {
    blank: boolean;
    allocations: number;
    frames: Scene[];
    views: { camera: PerspectiveCamera; bounds: Box3; quaternion: Quaternion }[];
    dispose: ReturnType<typeof vi.fn>;
    forceContextLoss: ReturnType<typeof vi.fn>;
  }[],
  environmentDispose: vi.fn(),
}));
vi.mock("three", async () => {
  const actual = await vi.importActual<typeof import("three")>("three");
  return {
    ...actual,
    WebGLRenderer: class {
      state = {
        blank: true,
        allocations: 0,
        frames: [] as Scene[],
        views: [] as { camera: PerspectiveCamera; bounds: Box3; quaternion: Quaternion }[],
        dispose: vi.fn(),
        forceContextLoss: vi.fn(),
      };
      constructor() {
        gpu.instances.push(this.state);
      }
      setDrawingBufferSize() {
        this.state.blank = true;
        this.state.allocations++;
      }
      render(scene: Scene, camera: PerspectiveCamera) {
        this.state.blank = false;
        this.state.frames.push(scene);
        const root = scene.children.find((child) => child instanceof actual.Group)!;
        root.updateMatrixWorld(true);
        camera.updateMatrixWorld(true);
        this.state.views.push({
          camera: camera.clone(),
          bounds: new actual.Box3().setFromObject(root),
          quaternion: root.quaternion.clone(),
        });
      }
      dispose() {
        this.state.dispose();
      }
      forceContextLoss() {
        this.state.forceContextLoss();
      }
    },
    PMREMGenerator: class {
      fromScene() {
        return { texture: new actual.Texture(), dispose: gpu.environmentDispose };
      }
      dispose() {}
    },
  };
});
const models = vi.hoisted(() => ({
  resolve: (_model: { asset: import("three").Group; dispose: () => void }) => {},
  signal: null as AbortSignal | null,
}));
vi.mock("./modelScene.ts", () => ({
  loadDeviceModel: (_source: unknown, signal: AbortSignal) => {
    models.signal = signal;
    return new Promise((resolve) => {
      models.resolve = resolve;
    });
  },
}));
import { Group, Mesh, MeshBasicMaterial, PlaneGeometry } from "three";
import { createDuoViewer } from "./duoViewer.ts";

afterEach(() => {
  vi.useRealTimers();
  vi.unstubAllGlobals();
  gpu.instances.length = 0;
  gpu.environmentDispose.mockClear();
});

function fixture(
  reduced = true,
  onOrientationRequested = vi.fn(),
  onPanelRequested?: (panel: 1 | 3) => void,
) {
  const pending = new Map<number, FrameRequestCallback>();
  let id = 0;
  vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => {
    pending.set(++id, callback);
    return id;
  });
  vi.stubGlobal("cancelAnimationFrame", (id: number) => pending.delete(id));
  vi.stubGlobal("matchMedia", () => ({ matches: reduced }));
  const drawImage = vi.fn();
  vi.stubGlobal("document", {
    createElement: () => ({
      width: 0,
      height: 0,
      getContext: () => ({
        fillRect() {},
        save() {},
        restore() {},
        translate() {},
        rotate() {},
        drawImage,
        getImageData: () => ({ data: new Uint8ClampedArray(8 * 8 * 4).fill(255) }),
      }),
    }),
  });
  const canvas = new EventTarget() as HTMLCanvasElement;
  const viewer = createDuoViewer({
    canvas,
    sources: {
      1: { width: 1398, height: 2034 } as HTMLCanvasElement,
      3: { width: 2007, height: 2853 } as HTMLCanvasElement,
    },
    model: { id: "iphone-duo", url: "/duo.glb" },
    onUnavailable: vi.fn(),
    onOrientationRequested,
    ...(onPanelRequested ? { onPanelRequested } : {}),
  });
  const draw = () => {
    const callbacks = [...pending.values()];
    pending.clear();
    callbacks.forEach((callback) => callback(0));
  };
  return { viewer, draw, pending, state: gpu.instances[0]!, onOrientationRequested, drawImage };
}

function asset() {
  const group = new Group();
  for (const [name, names] of [
    ["left-half", ["cover-display", "inner-display-left"]],
    ["right-half", ["inner-display-right"]],
  ] as const) {
    const leaf = new Group();
    leaf.name = name;
    for (const name of names) {
      const mesh = new Mesh(new PlaneGeometry(1, 2), new MeshBasicMaterial());
      if (name === "cover-display") mesh.geometry.rotateY(Math.PI);
      mesh.geometry.translate(
        name === "inner-display-right" ? 0.5 : -0.5,
        0,
        name === "cover-display" ? -0.05 : 0.05,
      );
      mesh.name = name;
      leaf.add(mesh);
    }
    group.add(leaf);
  }
  return group;
}

it("cancels loading and disposes a late model after unmount without installing or rendering it", async () => {
  const { viewer, draw, state } = fixture();
  viewer.resize(400, 700, 2);
  viewer.dispose();
  expect(models.signal?.aborted).toBe(true);
  const dispose = vi.fn();
  models.resolve({ asset: asset(), dispose });
  await Promise.resolve();
  draw();
  expect(dispose).toHaveBeenCalledOnce();
  expect(state.frames).toHaveLength(0);
});

it("uses the elected primary frame during handoff and never lets a stale fixed-panel feed overwrite it", async () => {
  const { viewer, drawImage } = fixture();
  const cover = {
    width: 1398,
    height: 2034,
    orientation: "portrait" as const,
    screenId: 1,
    hingeAngle: 90,
  };
  viewer.setScreen(cover);
  const primary = { width: 1398, height: 2034 } as HTMLCanvasElement;
  viewer.frameUpdated(1, primary);
  expect(drawImage.mock.calls.at(-1)?.[0]).toBe(primary);
  const uploads = drawImage.mock.calls.length;
  viewer.frameUpdated(1);
  expect(drawImage).toHaveBeenCalledTimes(uploads);
  viewer.frameUpdated(3, primary);
  expect(drawImage).toHaveBeenCalledTimes(uploads);
  viewer.setScreen({ ...cover, width: 2007, height: 2853, screenId: 3 });
  const inner = { width: 2007, height: 2853 } as HTMLCanvasElement;
  viewer.frameUpdated(3, inner);
  expect(drawImage.mock.calls.at(-1)?.[0]).toBe(inner);
  viewer.setScreen(cover);
  viewer.frameUpdated(1);
  expect(drawImage.mock.calls.length).toBeGreaterThan(uploads + 1);
  viewer.dispose();
});