Create polished demo videos without editing skills. Mac/Windows/Linux
import { expect, type Page, test } from "@playwright/test";
import { installDesktopBridge, installDesktopBridgeOverrides } from "./bridge";
// Front to back: Notes overlaps the left part of Safari.
const windows = [
{
id: "window:101:0",
appName: "Notes",
title: "Launch checklist",
display_id: "1",
x: 160,
y: 140,
width: 620,
height: 460,
},
{
id: "window:102:0",
appName: "Safari",
title: "Release notes",
display_id: "1",
x: 520,
y: 220,
width: 760,
height: 560,
},
];
async function openPicker(page: Page, allowArea = true, previousArea = false) {
await installDesktopBridge(page);
await installDesktopBridgeOverrides(
page,
({ pickerWindows, allowArea, previousArea }) => {
const api = (window as unknown as { electronAPI: Record<string, unknown> }).electronAPI;
Object.assign(api, {
getCapturePickerContext: async () => ({
displayBounds: { x: 0, y: 0, width: 1440, height: 1000 },
lastArea: previousArea ? { x: 100, y: 100, width: 400, height: 300 } : null,
allowArea,
windows: pickerWindows,
cursor: null,
}),
completeCapturePick: async (pick: unknown) => {
document.documentElement.dataset.pick = JSON.stringify(pick);
},
capturePickerReady: () => {
document.documentElement.dataset.pickerReady = "true";
},
});
},
{ pickerWindows: windows, allowArea, previousArea },
);
await page.goto("/?windowType=capture-picker&displayId=1");
await expect(page.locator("html")).toHaveAttribute("data-picker-ready", "true");
}
async function pick(page: Page) {
const value = await page.locator("html").getAttribute("data-pick");
return value ? JSON.parse(value) : undefined;
}
test("hovering highlights the frontmost window and a click picks it", async ({ page }) => {
await openPicker(page);
await page.mouse.move(600, 300);
await expect(page.getByText("Notes — Launch checklist · 620 × 460")).toBeVisible();
await page.screenshot({ path: "test-results/capture-picker.png", animations: "disabled" });
await page.mouse.click(600, 300);
expect(await pick(page)).toEqual({
kind: "window",
windowId: "window:101:0",
displayId: 1,
record: false,
});
});
test("a click on the desktop picks the whole screen", async ({ page }) => {
await openPicker(page);
await page.mouse.move(1380, 60);
await expect(page.getByText("Entire screen · 1440 × 1000")).toBeVisible();
await page.mouse.click(1380, 60);
expect(await pick(page)).toEqual({ kind: "screen", displayId: 1, record: false });
});
test("a drag draws an area", async ({ page }) => {
await openPicker(page);
await page.mouse.move(300, 200);
await page.mouse.down();
await page.mouse.move(700, 450, { steps: 8 });
await page.mouse.up();
await expect(page.getByText("Area · 400 × 250")).toBeVisible();
expect(await pick(page)).toBeUndefined();
await page.keyboard.press("Enter");
expect(await pick(page)).toMatchObject({
kind: "area",
width: 400,
height: 250,
displayId: 1,
record: false,
});
});
test("Escape cancels", async ({ page }) => {
await openPicker(page);
await page.keyboard.press("Escape");
expect(await pick(page)).toBeNull();
});
test("selection has no recording toolbar", async ({ page }) => {
await openPicker(page);
await page.mouse.click(600, 300);
await expect(page.getByRole("button", { name: "Record", exact: true })).toHaveCount(0);
expect(await pick(page)).toMatchObject({ kind: "window", record: false });
});
test("platforms without area capture keep drag selection on an existing screen", async ({
page,
}) => {
await openPicker(page, false);
await page.mouse.move(1300, 100);
await page.mouse.down();
await page.mouse.move(1380, 180, { steps: 8 });
await page.mouse.up();
expect(await pick(page)).toMatchObject({ kind: "screen", record: false });
});
for (const { selected, trigger } of [
{ selected: false, trigger: "source" },
{ selected: false, trigger: "record" },
{ selected: true, trigger: "source" },
]) {
test(`HUD ${selected ? "keeps the selected source" : "starts without a selected source"} and opens the picker only on ${trigger} click`, async ({
page,
}) => {
await installDesktopBridge(page);
await installDesktopBridgeOverrides(
page,
(selected) => {
Object.assign(window.electronAPI, {
getSelectedSource: async () =>
selected ? { id: "screen:1:0", name: "Existing screen" } : null,
pickCaptureTarget: async () => {
const html = document.documentElement;
html.dataset.pickerCalls = String(
Number(html.dataset.pickerCalls ?? 0) + 1,
);
return {
success: true,
source: { id: "window:101:0", name: "Selected window" },
};
},
});
},
selected,
);
await page.goto("/?windowType=hud-overlay");
const control = page.getByRole("button", { name: "Choose recording source" });
await expect(control).toBeEnabled();
if (selected) {
await expect(control).toContainText("Existing screen");
} else {
await expect(control).toHaveText("Pick screen");
}
await expect(page.locator("html")).not.toHaveAttribute("data-picker-calls");
await (trigger === "source"
? control
: page.getByRole("button", { name: "Record", exact: true })
).click();
await expect(page.locator("html")).toHaveAttribute("data-picker-calls", "1");
await expect(control).toContainText("Selected window");
await expect(page.getByRole("button", { name: "Record", exact: true })).toBeVisible();
});
}
test("a newer selected-source event wins over the startup response", async ({ page }) => {
await installDesktopBridge(page);
await installDesktopBridgeOverrides(page, () => {
Object.assign(window.electronAPI, {
getSelectedSource: async () => {
await new Promise((resolve) => setTimeout(resolve, 100));
document.documentElement.dataset.sourceResolved = "true";
return null;
},
onSelectedSourceChanged: (listener: (source: { name: string }) => void) => {
const timer = setTimeout(() => listener({ name: "Newer window" }), 10);
return () => clearTimeout(timer);
},
pickCaptureTarget: async () => {
document.documentElement.dataset.pickerCalls = "1";
return { success: false, canceled: true };
},
});
});
await page.goto("/?windowType=hud-overlay");
await expect(page.locator("html")).toHaveAttribute("data-source-resolved", "true");
await expect(page.getByRole("button", { name: "Choose recording source" })).toContainText(
"Newer window",
);
await expect(page.locator("html")).not.toHaveAttribute("data-picker-calls");
});
test("areas can be moved and resized before Enter confirms them", async ({ page }) => {
await openPicker(page);
await page.mouse.move(300, 200);
await page.mouse.down();
await page.mouse.move(700, 450, { steps: 8 });
await page.mouse.up();
await expect(page.getByText("Area · 400 × 250")).toBeVisible();
await page.mouse.move(400, 300);
await page.mouse.down();
await page.mouse.move(450, 350, { steps: 5 });
await page.mouse.up();
expect(await pick(page)).toBeUndefined();
const corner = page.locator('[data-area-handle="se"]');
const bounds = await corner.boundingBox();
if (!bounds) throw new Error("Missing area resize handle");
await page.mouse.move(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2);
await page.mouse.down();
await page.mouse.move(850, 600, { steps: 5 });
await page.mouse.up();
await expect(page.getByText("Area · 500 × 350")).toBeVisible();
await page.keyboard.press("Enter");
expect(await pick(page)).toMatchObject({
kind: "area",
x: 350,
y: 250,
width: 500,
height: 350,
record: false,
});
});
for (const resize of [false, true]) {
test(`area ${resize ? "resize" : "movement"} tracks pointer updates before the next render`, async ({
page,
}) => {
await openPicker(page);
await page.mouse.move(300, 200);
await page.mouse.down();
await page.mouse.move(700, 450);
await page.mouse.up();
await expect(page.getByText("Area · 400 × 250")).toBeVisible();
const start = resize ? { x: 700, y: 450 } : { x: 400, y: 300 };
await page.mouse.move(start.x, start.y);
await page.mouse.down();
await page.locator("div.fixed.inset-0.select-none").evaluate((overlay, start) => {
for (const delta of [50, 1]) {
overlay.dispatchEvent(
new PointerEvent("pointermove", {
bubbles: true,
pointerId: 1,
pointerType: "mouse",
buttons: 1,
clientX: start.x + delta,
clientY: start.y + delta,
}),
);
}
}, start);
await page.mouse.up();
await page.keyboard.press("Enter");
expect(await pick(page)).toMatchObject({
kind: "area",
x: resize ? 300 : 301,
y: resize ? 200 : 201,
width: resize ? 401 : 400,
height: resize ? 251 : 250,
record: false,
});
});
}
test("HUD reports a failed pick and keeps cancellation silent", async ({ page }) => {
await installDesktopBridge(page);
await installDesktopBridgeOverrides(page, () => {
let canceled = false;
Object.assign(window.electronAPI, {
getSelectedSource: async () => null,
pickCaptureTarget: async () => {
const result = {
success: false,
canceled,
message: "That window or screen is no longer available.",
};
canceled = true;
return result;
},
});
});
await page.goto("/?windowType=hud-overlay");
const source = page.getByRole("button", { name: "Choose recording source" });
await source.click();
await expect(
page.getByText("That window or screen is no longer available.", { exact: true }),
).toBeVisible();
await page.getByText("That window or screen is no longer available.", { exact: true }).hover();
await page.locator('[data-slot="toast-close"]').click();
await source.click();
await expect(source).toBeEnabled();
await expect(
page.getByText("That window or screen is no longer available.", { exact: true }),
).toHaveCount(0);
});
test("unselected source reads Pick screen once and Record stays disabled while picking", async ({
page,
}) => {
await installDesktopBridge(page);
await installDesktopBridgeOverrides(page, () => {
Object.assign(window.electronAPI, {
getSelectedSource: async () => null,
pickCaptureTarget: async () =>
new Promise((resolve) => {
(window as unknown as { finishPicker: () => void }).finishPicker = () =>
resolve({ success: false, canceled: true });
document.documentElement.dataset.pickerPending = "true";
}),
});
});
await page.goto("/?windowType=hud-overlay");
const source = page.getByRole("button", { name: "Choose recording source" });
await expect(source).toBeEnabled();
await expect(source).toHaveText("Pick screen");
await expect(page.locator("html")).not.toHaveAttribute("data-picker-pending");
await source.click();
await expect(page.locator("html")).toHaveAttribute("data-picker-pending", "true");
await expect(page.getByRole("button", { name: "Record", exact: true })).toBeDisabled();
await page.evaluate(() => (window as unknown as { finishPicker: () => void }).finishPicker());
await expect(page.getByRole("button", { name: "Record", exact: true })).toBeEnabled();
await expect(source).toHaveText("Pick screen");
});
test("changing source cancels countdown and discards native warm-up before opening the picker", async ({
page,
}) => {
await installDesktopBridge(page);
await installDesktopBridgeOverrides(page, () => {
let finishCountdown: (result: { success: boolean; cancelled: boolean }) => void;
const events: string[] = [];
Object.assign(window.electronAPI, {
startNativeScreenRecording: async () => ({ success: true }),
pauseNativeScreenRecording: async () => ({ success: true }),
resumeNativeScreenRecording: async () => {
events.push("resume");
return { success: true };
},
startCountdown: async () => {
document.documentElement.dataset.countdownStarted = "true";
return new Promise((resolve) => {
finishCountdown = resolve;
});
},
cancelCountdown: async () => {
events.push("cancel-countdown");
finishCountdown({ success: false, cancelled: true });
return { success: true };
},
stopNativeScreenRecording: async () => {
events.push("stop-native");
return { success: true, path: "/recordings/pending.mp4" };
},
deleteRecordingFile: async () => {
events.push("delete-file");
return { success: true };
},
setRecordingState: async (active: boolean) => {
if (active) events.push("recording");
},
pickCaptureTarget: async () => {
events.push("pick");
document.documentElement.dataset.events = JSON.stringify(events);
return { success: false, canceled: true };
},
});
});
await page.goto("/?windowType=hud-overlay");
await page.getByRole("button", { name: "Record", exact: true }).click();
await expect(page.locator("html")).toHaveAttribute("data-countdown-started", "true");
const source = page.getByRole("button", { name: "Choose recording source" });
await expect(source).toBeEnabled();
await source.click();
await expect(page.locator("html")).toHaveAttribute(
"data-events",
JSON.stringify(["cancel-countdown", "stop-native", "delete-file", "pick"]),
);
await expect(page.getByRole("button", { name: "Record", exact: true })).toBeEnabled();
});
test("recording and pause expose no interactive source picker", async ({ page }) => {
await installDesktopBridge(page);
await installDesktopBridgeOverrides(page, () => {
window.electronAPI.onRecordingStateChanged = (callback) => {
const listener = (event: Event) => callback((event as CustomEvent).detail);
window.addEventListener("test-recording", listener);
return () => window.removeEventListener("test-recording", listener);
};
window.electronAPI.pickCaptureTarget = async () => {
document.documentElement.dataset.pickerOpened = "true";
return { success: false, canceled: true };
};
});
await page.goto("/?windowType=hud-overlay");
await expect(page.getByRole("button", { name: "Choose recording source" })).toBeEnabled();
for (const paused of [false, true]) {
await page.evaluate(
(paused) =>
window.dispatchEvent(
new CustomEvent("test-recording", { detail: { recording: true, paused } }),
),
paused,
);
await expect(
page.getByRole("button", { name: "Choose recording source" }),
).not.toBeVisible();
await expect(page.locator("html")).not.toHaveAttribute("data-picker-opened");
}
});
test("changing source also cancels countdown on the browser capture path", async ({ page }) => {
await installDesktopBridge(page);
await installDesktopBridgeOverrides(page, () => {
let finishCountdown: (result: { success: boolean; cancelled: boolean }) => void;
Object.assign(window.electronAPI, {
getPlatform: async () => "linux",
startCountdown: async () => {
document.documentElement.dataset.countdownStarted = "true";
return new Promise((resolve) => {
finishCountdown = resolve;
});
},
cancelCountdown: async () => {
document.documentElement.dataset.countdownCancelled = "true";
finishCountdown({ success: false, cancelled: true });
return { success: true };
},
pickCaptureTarget: async () => {
document.documentElement.dataset.pickedAfterCancel =
document.documentElement.dataset.countdownCancelled;
return { success: false, canceled: true };
},
});
});
await page.goto("/?windowType=hud-overlay");
await page.getByRole("button", { name: "Record", exact: true }).click();
await expect(page.locator("html")).toHaveAttribute("data-countdown-started", "true");
await page.getByRole("button", { name: "Choose recording source" }).click();
await expect(page.locator("html")).toHaveAttribute("data-picked-after-cancel", "true");
await expect(page.getByRole("button", { name: "Record", exact: true })).toBeEnabled();
});
test("reopening an area starts with window picking instead of the old area editor", async ({
page,
}) => {
await openPicker(page, true, true);
await expect(page.locator("[data-area-handle]")).toHaveCount(0);
await page.mouse.move(600, 300);
await expect(page.getByText("Notes — Launch checklist · 620 × 460")).toBeVisible();
await page.mouse.click(600, 300);
expect(await pick(page)).toMatchObject({ kind: "window", windowId: "window:101:0" });
});
for (const destination of ["window", "screen"] as const) {
test(`a drawn area can return to ${destination} picking without closing the picker`, async ({
page,
}) => {
await openPicker(page);
await page.mouse.move(300, 200);
await page.mouse.down();
await page.mouse.move(700, 450, { steps: 5 });
await page.mouse.up();
await expect(page.getByText("Area · 400 × 250")).toBeVisible();
const change = page.getByRole("button", { name: "Choose another source", exact: true });
if (destination === "window") {
await change.focus();
await page.keyboard.press("Enter");
} else {
await change.click();
}
await expect(page.locator("[data-area-handle]")).toHaveCount(0);
expect(await pick(page)).toBeUndefined();
const point = destination === "window" ? { x: 600, y: 300 } : { x: 1380, y: 60 };
await page.mouse.move(point.x, point.y);
await expect(
page.getByText(
destination === "window"
? "Notes — Launch checklist · 620 × 460"
: "Entire screen · 1440 × 1000",
),
).toBeVisible();
await page.mouse.click(point.x, point.y);
expect(await pick(page)).toMatchObject({ kind: destination, displayId: 1, record: false });
});
}