Skip to content

Create polished demo videos without editing skills. Mac/Windows/Linux

Merge the author's latest capture-picker fixes from PR #1090

webadderallc4a73f7580ce
diff --cc electron/ipc/register/capturePicker.test.ts
index 3733e7b9,00000000..1b5625c3
mode 100644,000000..100644
--- a/electron/ipc/register/capturePicker.test.ts
+++ b/electron/ipc/register/capturePicker.test.ts
@@@ -1,224 -1,0 +1,223 @@@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+const mocks = vi.hoisted(() => ({
+ handlers: new Map<string, (...args: unknown[]) => unknown>(),
+ list: vi.fn(),
+ pickSourceList: vi.fn(),
+ validate: vi.fn(),
+ remember: vi.fn(),
+ selected: vi.fn(),
+ recording: false,
+ currentSource: null as Record<string, unknown> | null,
+ create: vi.fn(),
+ close: vi.fn(),
+ overlay: {},
+ outsider: {},
+ windows: [] as object[],
+}));
+vi.mock("electron", () => ({
+ ipcMain: {
+ handle: (name: string, handler: (...args: unknown[]) => unknown) =>
+ mocks.handlers.set(name, handler),
+ },
- BrowserWindow: { fromWebContents: (sender: unknown) => sender },
+}));
+vi.mock("../../windows", () => ({
+ createCapturePickerWindows: mocks.create,
+ closeCapturePickerWindows: mocks.close,
- getCapturePickerWindows: () => mocks.windows,
++ isCapturePickerWebContents: (sender: object) => mocks.windows.includes(sender),
+}));
+vi.mock("../captureSelection", () => ({
+ validateCaptureSource: mocks.validate,
+ rememberCaptureSource: mocks.remember,
+}));
+vi.mock("../capturePickerSources", () => ({ listCapturePickerWindows: mocks.list }));
+vi.mock("../cursor/bounds", () => ({ stopWindowBoundsCapture: vi.fn() }));
+vi.mock("../state", () => ({
+ setSelectedSource: mocks.selected,
+ get isCursorCaptureActive() {
+ return mocks.recording;
+ },
+ get selectedSource() {
+ return mocks.currentSource;
+ },
+}));
+vi.mock("../utils", () => ({
+ getScreen: () => ({
+ getAllDisplays: () => [{ id: 1, bounds: { x: 0, y: 0, width: 1440, height: 1000 } }],
+ getPrimaryDisplay: () => ({ id: 1 }),
+ getCursorScreenPoint: () => ({ x: 0, y: 0 }),
+ }),
+}));
+vi.mock("./sources", () => ({
+ bringSelectedWindowForward: vi.fn(),
+ broadcastSelectedSourceChange: vi.fn(),
+ getDesktopSources: vi.fn().mockResolvedValue([{ id: "screen:1:0", display_id: "1" }]),
+}));
+import { registerCapturePickerHandlers } from "./capturePicker";
+const platform = process.platform;
+afterEach(() => {
+ Object.defineProperty(process, "platform", { value: platform });
+ vi.unstubAllEnvs();
+});
+beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.handlers.clear();
+ mocks.currentSource = null;
+ mocks.recording = false;
+ mocks.windows = [mocks.overlay];
+ Object.defineProperty(process, "platform", { value: "darwin" });
+ mocks.list.mockResolvedValue([]);
+ mocks.validate.mockImplementation(async (source) => source);
+ registerCapturePickerHandlers({ pickSourceList: mocks.pickSourceList });
+});
+const call = (name: string, sender: object, input?: unknown) =>
+ mocks.handlers.get(name)!({ sender }, input);
+describe("selection-only picker IPC", () => {
+ it("ignores completion from other windows and forces selection-only completion", async () => {
+ const pending = call("pick-capture-target", mocks.outsider);
+ await vi.waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());
+ await call("complete-capture-pick", mocks.outsider, {
+ kind: "screen",
+ displayId: 1,
+ record: true,
+ });
+ expect(mocks.selected).not.toHaveBeenCalled();
+ await call("complete-capture-pick", mocks.overlay, {
+ kind: "screen",
+ displayId: 1,
+ record: true,
+ });
+ expect(await pending).toMatchObject({ success: true, source: { id: "screen:1:0" } });
+ expect(await pending).not.toHaveProperty("record");
+ });
+ it("coalesces simultaneous opens into one picker", async () => {
+ const first = call("pick-capture-target", mocks.outsider);
+ const second = call("pick-capture-target", mocks.outsider);
+ await vi.waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());
+ await call("complete-capture-pick", mocks.overlay, null);
+ expect(await first).toEqual({ success: false, canceled: true });
+ expect(await second).toEqual({ success: false, canceled: true });
+ });
+ it("keeps Wayland on the existing portal path without overlays or geometry probes", async () => {
+ Object.defineProperty(process, "platform", { value: "linux" });
+ vi.stubEnv("XDG_SESSION_TYPE", "wayland");
+ expect(await call("pick-capture-target", mocks.outsider)).toMatchObject({
+ success: true,
+ source: { id: "screen:linux-portal" },
+ });
+ expect(mocks.create).not.toHaveBeenCalled();
+ expect(mocks.list).not.toHaveBeenCalled();
+ });
+});
+
+it("rejects a window that disappeared while the picker was open", async () => {
+ mocks.list.mockResolvedValue([
+ {
+ id: "window:101:0",
+ title: "Document",
+ appName: "Notes",
+ x: 0,
+ y: 0,
+ width: 400,
+ height: 300,
+ },
+ ]);
+ mocks.validate.mockResolvedValue(null);
+ const pending = call("pick-capture-target", mocks.outsider);
+ await vi.waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());
+ await call("complete-capture-pick", mocks.overlay, {
+ kind: "window",
+ windowId: "window:101:0",
+ displayId: 1,
+ });
+ expect(await pending).toMatchObject({
+ success: false,
+ message: "That window or screen is no longer available.",
+ });
+ expect(mocks.selected).not.toHaveBeenCalled();
+ expect(mocks.remember).not.toHaveBeenCalled();
+});
+it("surfaces detection failures instead of opening a screen-only overlay", async () => {
+ mocks.list.mockRejectedValue(new Error("Unable to detect windows"));
+ expect(await call("pick-capture-target", mocks.outsider)).toMatchObject({
+ success: false,
+ message: "Unable to detect windows",
+ });
+ expect(mocks.create).not.toHaveBeenCalled();
+ expect(mocks.selected).not.toHaveBeenCalled();
+});
+
+it("reopens the currently selected saved area, without reusing an old area for a window", async () => {
+ mocks.currentSource = {
+ id: "area:1",
+ display_id: "1",
+ area: { x: 100, y: 200, width: 400, height: 300 },
+ };
+ expect(await call("get-capture-picker-context", mocks.overlay, 1)).toMatchObject({
+ lastArea: mocks.currentSource.area,
+ });
+ mocks.currentSource = { id: "window:101:0", display_id: "1" };
+ expect(await call("get-capture-picker-context", mocks.overlay, 1)).toMatchObject({
+ lastArea: null,
+ });
+});
+
+it("does not open any source picker during recording or pause", async () => {
+ mocks.recording = true;
+ expect(await call("pick-capture-target", mocks.outsider)).toEqual({
+ success: false,
+ canceled: true,
+ });
+ expect(mocks.list).not.toHaveBeenCalled();
+ expect(mocks.create).not.toHaveBeenCalled();
+ expect(mocks.selected).not.toHaveBeenCalled();
+});
+
+it("rejects a pending selection if recording starts while the picker is open", async () => {
+ const pending = call("pick-capture-target", mocks.outsider);
+ await vi.waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());
+ mocks.recording = true;
+ await call("complete-capture-pick", mocks.overlay, { kind: "screen", displayId: 1 });
+ expect(await pending).toEqual({ success: false, canceled: true });
+ expect(mocks.selected).not.toHaveBeenCalled();
+});
+
+it("does not open overlays if recording starts while listing windows", async () => {
+ mocks.list.mockImplementation(async () => {
+ mocks.recording = true;
+ return [];
+ });
+ expect(await call("pick-capture-target", mocks.outsider)).toEqual({
+ success: false,
+ canceled: true,
+ });
+ expect(mocks.create).not.toHaveBeenCalled();
+});
+
+it("keeps X11 on the source list and coalesces concurrent opens", async () => {
+ Object.defineProperty(process, "platform", { value: "linux" });
+ vi.stubEnv("XDG_SESSION_TYPE", "x11");
+ let finish!: (result: unknown) => void;
+ mocks.pickSourceList.mockReturnValue(
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const first = call("pick-capture-target", mocks.outsider);
+ const second = call("pick-capture-target", mocks.outsider);
+ expect(mocks.pickSourceList).toHaveBeenCalledOnce();
+ expect(mocks.list).not.toHaveBeenCalled();
+ expect(mocks.create).not.toHaveBeenCalled();
+ finish({ success: false, canceled: true });
+ expect(await first).toEqual({ success: false, canceled: true });
+ expect(await second).toEqual({ success: false, canceled: true });
+});
+it("keeps the X11 source list closed during recording", async () => {
+ Object.defineProperty(process, "platform", { value: "linux" });
+ vi.stubEnv("XDG_SESSION_TYPE", "x11");
+ mocks.recording = true;
+ expect(await call("pick-capture-target", mocks.outsider)).toEqual({
+ success: false,
+ canceled: true,
+ });
+ expect(mocks.pickSourceList).not.toHaveBeenCalled();
+});
diff --cc electron/ipc/register/capturePicker.ts
index 8c26ae39,4b93088b..9c6ead38
--- a/electron/ipc/register/capturePicker.ts
+++ b/electron/ipc/register/capturePicker.ts
@@@ -1,27 -1,50 +1,27 @@@
+import { rememberCaptureSource, validateCaptureSource } from "../captureSelection";
+import { listCapturePickerWindows } from "../capturePickerSources";
- import { BrowserWindow, ipcMain } from "electron";
+ import { ipcMain } from "electron";
+import type { SourceListPickResult } from "../../sourceListPicker";
import {
closeCapturePickerWindows,
createCapturePickerWindows,
- getCapturePickerWindows,
+ isCapturePickerWebContents,
} from "../../windows";
-import { getNativeMacWindowsFrontToBack, stopWindowBoundsCapture } from "../cursor/bounds";
-import { setSelectedSource } from "../state";
-import { createAreaSource, createWindowSource, normalizeCapturePick } from "../sourceArea";
-import type { AreaCapturePick, CapturePick, CapturePickerWindow, SelectedSource } from "../types";
+import { stopWindowBoundsCapture } from "../cursor/bounds";
+import { isCursorCaptureActive, selectedSource, setSelectedSource } from "../state";
+import {
+ createAreaSource,
+ createWindowSource,
+ getSourceArea,
+ normalizeCapturePick,
+} from "../sourceArea";
+import type { CapturePick, CapturePickerWindow, SelectedSource } from "../types";
import { getScreen } from "../utils";
-import { getScreenSourceIdForDisplay } from "./sourceMapping";
-import { bringSelectedWindowForward, broadcastSelectedSourceChange } from "./sources";
-
-/** Windows the picker can offer, front to back, without Recordly's own. */
-async function listPickableWindows(): Promise<CapturePickerWindow[]> {
- const entries = await getNativeMacWindowsFrontToBack();
- return entries.flatMap((entry) => {
- const { x, y, width, height } = entry;
- if (
- entry.ownerPid === process.pid ||
- typeof x !== "number" ||
- typeof y !== "number" ||
- typeof width !== "number" ||
- typeof height !== "number" ||
- width <= 0 ||
- height <= 0
- ) {
- return [];
- }
- return [
- {
- id: entry.id,
- appName: entry.appName ?? "",
- title: entry.windowTitle ?? entry.name,
- display_id: entry.display_id,
- x,
- y,
- width,
- height,
- },
- ];
- });
-}
+import { getScreenSourceIdForDisplay, isLikelyLinuxWaylandSession } from "./sourceMapping";
+import { broadcastSelectedSourceChange, getDesktopSources } from "./sources";
/** The same source the screen list offers for this display. */
-function createScreenSource(displayId: number): SelectedSource | null {
+async function createScreenSource(displayId: number): Promise<SelectedSource | null> {
const displays = getScreen().getAllDisplays();
const index = displays.findIndex((display) => display.id === displayId);
if (index < 0) return null;
@@@ -149,34 -120,19 +149,32 @@@ export function registerCapturePickerHa
});
ipcMain.handle("complete-capture-pick", async (event, input: unknown) => {
- if (!getCapturePickerWindows().includes(BrowserWindow.fromWebContents(event.sender)!))
- return;
- // Only the picker overlays answer a pick.
+ if (!isCapturePickerWebContents(event.sender)) return;
- if (!input) {
+ if (
+ input &&
+ typeof input === "object" &&
+ (input as { kind?: unknown }).kind === "area" &&
+ process.platform !== "darwin"
+ )
+ return;
+ if (!input || isCursorCaptureActive) {
finishPick(null);
return;
}
const displays = getScreen()
.getAllDisplays()
.map((display) => ({ id: display.id, bounds: display.bounds }));
- finishPick(normalizeCapturePick(input, displays, await pickableWindows));
+ finishPick(
+ normalizeCapturePick(
+ input && typeof input === "object" ? { ...input, record: false } : input,
+ displays,
+ await pickableWindows,
+ ),
+ );
});
- ipcMain.handle("get-capture-picker-context", async (_, displayId: unknown) => {
+ ipcMain.handle("get-capture-picker-context", async (event, displayId: unknown) => {
- if (!getCapturePickerWindows().includes(BrowserWindow.fromWebContents(event.sender)!))
- throw new Error("Unknown picker window.");
++ if (!isCapturePickerWebContents(event.sender)) throw new Error("Unknown picker window.");
const display = getScreen()
.getAllDisplays()
.find((entry) => entry.id === Number(displayId));
diff --cc tests/ui/capture-picker.spec.ts
index 25ac875a,8e32093f..e7d12c5a
--- a/tests/ui/capture-picker.spec.ts
+++ b/tests/ui/capture-picker.spec.ts
@@@ -105,267 -101,3 +105,339 @@@ test("Escape cancels", async ({ 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 page.addInitScript((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 source");
+ }
+ 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 page.addInitScript(() => {
+ 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 page.addInitScript(() => {
++ 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 source once and Record stays disabled while picking", async ({
+ page,
+}) => {
+ await installDesktopBridge(page);
+ await page.addInitScript(() => {
+ 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 source");
+ 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 source");
+});
+
+test("changing source cancels countdown and discards native warm-up before opening the picker", async ({
+ page,
+}) => {
+ await installDesktopBridge(page);
+ await page.addInitScript(() => {
+ 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 page.addInitScript(() => {
+ 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 page.addInitScript(() => {
+ 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();
+});