Compare commits

..
34 changed files with 1395 additions and 437 deletions

No files matched your search

+1 -1
View File
@@ -217,7 +217,7 @@ exploration:
- /c/[channel]
```
An excluded route stays in its neighbors' navigation context (a screen that links to it is still captured when it changes), but neither revision captures it, it is left off the map and the screen counts, and a change to it gets no before/after comparison. A name that matches no route at either compared revision fails the plan with `EXCLUDE_ROUTE_UNKNOWN`; `doctor` warns about it first. Prefer `parameters` or `setup` when a route does show a screen.
An excluded route stays in its neighbors' navigation context (a screen that links to it is still captured when it changes), but neither revision captures it, it is left off the report (the Map, Screens, search and the screen counts), and a change to it gets no before/after comparison. A name that matches no route at either compared revision fails the plan with `EXCLUDE_ROUTE_UNKNOWN`; `doctor` warns about it first. Prefer `parameters` or `setup` when a route does show a screen.
Capture handles iOS's confirmation to open a link in the expected app. After a form submits a password, iOS may offer to save or update it depending on the simulator's AutoFill state; capture declines that prompt with Not Now in both modes, never stores the credential, and records each decision in `capture-diagnostics/system-prompts.jsonl`. Do not script that tap in setup. Include required system-alert handling in setup or app instructions; Explore does not automatically grant application permissions.
+2 -2
View File
@@ -1,12 +1,12 @@
{
"name": "@expo/explore",
"version": "0.20.0-next.0",
"version": "0.20.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "@expo/explore",
"version": "0.20.0-next.0",
"version": "0.20.0",
"license": "MIT",
"dependencies": {
"@expo/repack-app": "0.10.1",
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/explore",
"version": "0.20.0-next.0",
"version": "0.20.0",
"description": "Source-driven mobile app maps, deterministic CI capture, and visual reviews",
"license": "MIT",
"type": "module",
+73
View File
@@ -0,0 +1,73 @@
import type { PublicReview } from "./capture.js";
import { navigationCaptureContext } from "./navigation-graph.js";
type Surface = PublicReview["surfaces"][number];
type Side = "base" | "head";
/** Navigation is route-level: a secondary-appearance surface (`<id>@<scheme>`) rides on its route's entry. */
const SCHEME_SUFFIX = /@(light|dark)$/;
const routeOf = (id: string): string => id.replace(SCHEME_SUFFIX, "");
/**
* The surfaces a side planned to capture: every route in `all` mode, the changed routes and their navigation context in
* `changes` mode. Undefined without navigation, which leaves no route outside the context.
*/
export function captureContext(review: PublicReview, side: Side): ReadonlySet<string> | undefined {
const navigation = review.navigation?.[side];
if (!navigation) return undefined;
const inventory = review.surfaces.filter((surface) => surface[side]);
const routes = new Map<string, NonNullable<Surface[Side]>>();
for (const surface of inventory) {
const id = routeOf(surface.id);
if (!routes.has(id)) routes.set(id, { ...surface[side]!, id });
}
const selected = new Set(review.mode === "all" ? [...routes.keys()] : navigationCaptureContext(navigation,
inventory.filter((surface) => surface.status !== "unchanged").map((surface) => routeOf(surface.id)),
[...routes.values()]));
return new Set(inventory.filter((surface) => selected.has(routeOf(surface.id))).map((surface) => surface.id));
}
/** Both a screenshot of the planned route and a verified landing on it. */
export function verifiedCapture(surface: Surface, side: Side): boolean {
const outcome = side === "base" ? surface.baseOutcome : surface.headOutcome;
return Boolean(surface[side]?.kind === "screen" && (side === "base" ? surface.baseImage : surface.headImage)
&& outcome?.status === "captured" && outcome.landing === "verified");
}
/**
* Why a side that exists in its revision has no verified capture, as the report's capture gap: `accepted` when the run
* left it uncaptured on purpose (a redirect declaration, a route named in `exploration.exclude`, or a route outside the
* capture context), `open` for anything else, such as a capture that failed. Undefined for a verified capture or an
* absent side. `context` is the side's `captureContext`.
*/
export function captureGap(review: PublicReview, surface: Surface, side: Side,
context: ReadonlySet<string> | undefined): "accepted" | "open" | undefined {
const entry = surface[side];
if (!entry || verifiedCapture(surface, side)) return undefined;
const image = side === "base" ? surface.baseImage : surface.headImage;
const outcome = side === "base" ? surface.baseOutcome : surface.headOutcome;
const outsideCaptureContext = review.mode === "changes" && context !== undefined && !context.has(surface.id);
const deliberate = !image && !outcome && (entry.kind === "redirect" || surface.excluded === true || outsideCaptureContext
|| (!review.navigation?.[side] && review.mode === "changes" && surface.status === "unchanged"));
return deliberate ? "accepted" : "open";
}
/**
* The surfaces the run never captured on purpose: no screenshot of their own on either side, and every side that exists
* left uncaptured deliberately (`captureGap` is `accepted`). None is one of the report's screens. The Viewer leaves them
* out (viewer/src/utils/omitted-screens.ts reaches the same set from the map's gaps), and the PR comment skips them.
* A side with an open gap, such as a failed capture, keeps the surface: its failure is part of the report.
*/
export function neverCapturedSurfaceIds(review: PublicReview): ReadonlySet<string> {
// The Viewer refuses a review whose navigation names a route its inventory lacks; the comment still renders one,
// without a capture context, so no route counts as outside it.
const contextOf = (side: Side) => { try { return captureContext(review, side); } catch { return undefined; } };
const contexts = { base: contextOf("base"), head: contextOf("head") };
const omitted = new Set<string>();
for (const surface of review.surfaces) {
if (surface.baseImage || surface.headImage) continue;
const gaps = (["base", "head"] as const).map((side) => captureGap(review, surface, side, contexts[side]));
if (gaps.includes("accepted") && !gaps.includes("open")) omitted.add(surface.id);
}
return omitted;
}
+8 -3
View File
@@ -5,6 +5,7 @@ import { CI_COMMENT_MARKER } from "./pr-comment.js";
import { CHANGE_GROUPS, MAX_COMMENT_TARGETS, MAX_NAVIGATION_EDGES, MAX_NAVIGATION_NODES, compareTargets, defaultTargetLabel, foldRecord, strongerGroup, historyLine, orderedPrevious, orderedRecords, previousLine, readCommentRecords, recordLabel, recordLine, recordSummary,
type ChangeGroup, type CommentNavigation, type CommentTarget, type CommentRecords, type HistoryEntry, type NavigationGroup, type NavigationKind, type PlatformRecord } from "./pr-comment-record.js";
import { isAccessibilityOnlyChange } from "../contracts/review-validation.js";
import { neverCapturedSurfaceIds } from "../contracts/surface-capture.js";
import type { PublicCaptureHealth, PublicEvidenceSummary } from "../review/evidence-assessment.js";
import type { ReviewPresentation } from "../contracts/review.js";
import type { ViewerLinks } from "./viewer-links.js";
@@ -294,8 +295,10 @@ export function platformRecordOf(state: PublicCommentState, target?: CommentTarg
if (state.review) {
const evidenceBased = state.review.surfaces.some(surface => surface.review);
record.changes = [];
// A route the run never captured on purpose is not one of the report's screens, here as in the Viewer.
const omitted = neverCapturedSurfaceIds(state.review);
for (const surface of state.review.surfaces) {
if ((surface.head ?? surface.base)?.kind === "redirect") continue;
if (omitted.has(surface.id)) continue;
const group = groupOf(surface, evidenceBased);
if (group === "unlisted") continue;
const scheme = schemeOf(surface.id);
@@ -348,9 +351,10 @@ function navigationOf(review: PublicReview, groups: Map<string, ChangeGroup>): C
if (!review.navigation) return undefined;
const keyOf = new Map<string, string>();
const groupOf = new Map<string, NavigationGroup>();
const omitted = neverCapturedSurfaceIds(review);
for (const surface of review.surfaces) {
const route = surface.head ?? surface.base;
if (!route || route.kind === "redirect") continue;
if (!route || omitted.has(surface.id)) continue;
const key = routePattern(route);
keyOf.set(surface.id.replace(/@(light|dark)$/, ""), key);
const group = groups.get(surface.id);
@@ -718,8 +722,9 @@ export function reviewDevice(state: { runtime?: Pick<SimulatorRuntimeMetadata, "
export function reviewChanges(review: PublicReview): Map<string, ChangeGroup> {
const evidenceBased = review.surfaces.some(surface => surface.review);
const changes = new Map<string, ChangeGroup>();
const omitted = neverCapturedSurfaceIds(review);
for (const surface of review.surfaces) {
if ((surface.head ?? surface.base)?.kind === "redirect") continue;
if (omitted.has(surface.id)) continue;
const group = groupOf(surface, evidenceBased);
if (group !== "unlisted") changes.set(surface.id, group);
}
+97 -9
View File
@@ -1346,7 +1346,7 @@ test("transition thumbnails without a readable screenshot show the variant thumb
assert.deepEqual(errors, []);
});
test("a docs-only report with zero images and no EAS build opens Screens without a visual verdict", async t => {
test("a docs-only report with zero images and no EAS build has no screens to show, and its link to a route says why", async t => {
const report = reportFixture();
report.review.mode = "changes";
report.review.runtime.projectId = "";
@@ -1359,12 +1359,11 @@ test("a docs-only report with zero images and no EAS build opens Screens without
report.assets = [];
const { page, errors } = await harness(t, await archive(report), { app: true });
await expect(page.locator(".app-shell")).toBeVisible();
await page.getByRole("button", { name: "Screens", exact: true }).click();
await expect(page.locator(".screens-page .screens-cell")).toHaveCount(1);
await expect(page.locator(".screens-page .diff-frame.diff-not-compared")).toHaveCount(1);
// The Inspector's missing screenshot matches the canvas node: the icon above a short label and
// the report's reason for the gap, centred in a phone-shaped preview frame.
await page.locator(".screens-page .screen-screenshot-target").click();
// The change reaches no screen, so the one route was never captured: the Map and Screens say so instead of an empty page.
const empty = page.locator(".map-empty");
await expect(empty.getByRole("heading")).toHaveText("No screens were captured");
// The link names /home, and the Inspector says why it has no screenshot: the icon above a short label and the report's
// reason for the gap, centred in a phone-shaped preview frame.
const placeholder = page.locator(".inspector .inspector-preview .screenshot-placeholder");
await expect(placeholder.locator("span")).toHaveText("No screenshot");
await expect(placeholder.locator(".screenshot-placeholder-detail")).toHaveText("Not compared; no capture was recorded");
@@ -1390,10 +1389,98 @@ test("a docs-only report with zero images and no EAS build opens Screens without
await expect(page.locator(".collapsed-change-count")).toHaveCount(0);
await expect(page.locator(".changes-screen-row")).toHaveCount(0);
await expect(page.locator(".diff-frame.diff-modified, .diff-frame.diff-unchanged")).toHaveCount(0);
await page.getByRole("button", { name: "Screens", exact: true }).click();
await expect(empty.getByRole("heading")).toHaveText("No screens were captured");
await expect(page.locator(".screens-cell, .screens-tree-row")).toHaveCount(0);
assert.equal(await page.evaluate(() => window.createdUrls.length), 0);
assert.deepEqual(errors, []);
});
/** A report with Home (modified) and Profile (not compared) captured, a new route named in exploration.exclude, and a redirect. */
function omittedRoutesReport() {
const report = reportFixture();
const home = report.review.surfaces[0];
const route = (id, path, extra = {}) => ({ ...home.head, id, route: path, path, routeFile: `app/${id}.tsx`, logicalPath: `app/${id}.tsx`, ...extra });
const redirect = route("start", "/start", { kind: "redirect", redirectTo: "/home" });
report.review.surfaces.push(
{ id: "profile", status: "unchanged", base: route("profile", "/profile"), head: route("profile", "/profile"),
baseImage: { ...home.baseImage }, headImage: { ...home.headImage }, baseOutcome: { ...home.baseOutcome }, headOutcome: { ...home.headOutcome } },
{ id: "channel", status: "added", excluded: true, base: null, head: route("channel", "/c/[channel]") },
{ id: "start", status: "unchanged", base: { ...redirect }, head: redirect });
return report;
}
test("a public report's excluded route and redirect are not among its screens: Screens, its counts, find, search and the changes leave them out", { timeout: 60_000 }, async t => {
const { page, errors } = await harness(t, await archive(omittedRoutesReport()), { app: true, query: "&screen=home" });
await expect(page.locator(".map-canvas .react-flow__node")).toHaveCount(2);
// The excluded route is new in this change, but it was never captured: it is not a change to review.
const menu = await openChangesMenu(page);
await expect(menu.getByRole("group", { name: "Filter changes" }).getByRole("button")).toHaveText(["Modified 1"]);
await expect(menu.getByText("/c/[channel]")).toHaveCount(0);
await page.keyboard.press("Escape");
await page.getByRole("button", { name: "Screens", exact: true }).click();
const cells = page.locator(".screens-page .screens-cell");
await expect(cells).toHaveCount(2);
await expect(page.locator(".screens-tree-row[data-screen-id]")).toHaveCount(2);
for (const id of ["channel", "start"]) await expect(page.locator(`[data-screen-id="${id}"]`)).toHaveCount(0);
await expect(page.locator(".screens-filter .screens-chip")).toHaveText(["Changed1", "All2"]);
// ← and → step through the two screens and no others.
await page.locator(".screens-page").click({ position: { x: 4, y: 4 } });
await page.keyboard.press("ArrowRight");
await expect(page.locator(".screens-cell .screen-screenshot-card.selected")).toHaveCount(1);
const picked = async () => page.locator(".screens-cell:has(.screen-screenshot-card.selected)").getAttribute("data-screen-id");
const first = await picked();
await page.keyboard.press("ArrowRight");
await expect.poll(picked).not.toBe(first);
const second = await picked();
await page.keyboard.press("ArrowRight");
await expect.poll(picked).toBe(second);
assert.deepEqual([first, second].sort(), ["home", "profile"]);
// `/` finds the report's screens only.
await page.keyboard.press("/");
const find = page.getByRole("searchbox", { name: "Find screens" });
await expect(find).toBeFocused();
for (const query of ["channel", "start"]) {
await find.fill(query);
await expect(page.locator(".screens-find-empty")).toHaveText(`No screens match “${query}”`);
await expect(cells).toHaveCount(0);
}
await find.fill("profile");
await expect(cells).toHaveCount(1);
await page.keyboard.press("Escape");
await page.keyboard.press("Escape");
// So does the command palette's screen search.
await page.keyboard.press("ControlOrMeta+KeyK");
const palette = page.getByRole("dialog", { name: "Search Explore" });
const box = palette.getByRole("combobox", { name: "Search screens and commands" });
await expect(box).toBeFocused();
await box.fill("/c/");
await expect(palette.getByRole("option")).toHaveCount(0);
await box.fill("/st");
await expect(palette.getByRole("option")).toHaveCount(0);
await box.fill("/pro");
await expect(palette.getByRole("option")).toHaveText([/\/profile/]);
assert.deepEqual(errors, []);
});
test("a link to an excluded route opens it in the Inspector, which says why it has no screenshot, on the Map and on Screens", { timeout: 60_000 }, async t => {
const { page, errors } = await harness(t, await archive(omittedRoutesReport()), { app: true, query: "&screen=channel" });
const detail = page.locator(".inspector .inspector-preview .screenshot-placeholder-detail");
await expect(detail).toHaveText("Excluded by exploration.exclude; never captured");
await expect(page.locator(".map-canvas .react-flow__node")).toHaveCount(2);
await expect(page.locator(".map-canvas .react-flow__node.selected")).toHaveCount(0);
// The same link on Screens, opened afresh: no card is picked, and the Inspector explains the route.
await page.goto(page.url().replace("#/map/", "#/screens/"));
await page.reload();
await expect(page.locator(".screens-page .screens-cell")).toHaveCount(2);
await expect(page.locator(".screens-cell .screen-screenshot-card.selected")).toHaveCount(0);
await expect(detail).toHaveText("Excluded by exploration.exclude; never captured");
assert.deepEqual(errors, []);
});
test("unverified capture diagnostics stay separate from verified Needs review, and source changes nobody compared are not changes", async t => {
const report = reportFixture();
const home = report.review.surfaces[0];
@@ -1507,10 +1594,11 @@ test("a recorded pull-request artifact opens its verified verdicts and every scr
await expect(menu.getByText(route, { exact: true })).toBeVisible();
}
// Its two redirect declarations (/ and /scan/select-photo) were never captured: they are not among its screens.
await page.getByRole("button", { name: "Screens", exact: true }).click();
const frames = page.locator(".screens-page .diff-frame");
await expect(frames).toHaveCount(35);
for (const [status, count] of [["modified", 3], ["added", 1], ["removed", 1], ["unchanged", 28], ["not-compared", 2]]) {
await expect(frames).toHaveCount(33);
for (const [status, count] of [["modified", 3], ["added", 1], ["removed", 1], ["unchanged", 28], ["not-compared", 0]]) {
await expect(page.locator(`.screens-page .diff-frame.diff-${status}`)).toHaveCount(count);
}
const screenshots = page.locator(".screens-page img[data-screenshot-src]");
+11 -3
View File
@@ -242,6 +242,14 @@ test("Compare steps through changed screens and their changed areas", { timeout:
await expect(outlines.nth(1)).toHaveClass(/active/);
await page.keyboard.press("k");
await expect(outlines.nth(0)).toHaveClass(/active/);
// Esc in the bottom bar's More menu closes the menu and only the menu.
const more = page.getByRole("button", { name: "More", exact: true });
await more.click();
await expect(page.getByRole("menu", { name: "More" })).toBeVisible();
await page.keyboard.press("Escape");
await expect(page.getByRole("menu", { name: "More" })).toHaveCount(0);
await expect(more).toBeFocused();
await expect(outlines.nth(0)).toHaveClass(/active/);
await page.keyboard.press("Escape");
await expect(compare.locator(".visual-change-outline.active")).toHaveCount(0);
@@ -310,7 +318,7 @@ test("Compare steps through changed screens and their changed areas", { timeout:
/** The Inspector's one frame for a screen outside the review, and its Swipe frame for a changed one, in this viewport. */
async function inspectorFrames(page, url) {
const games = "expo-tabs-games-index-2c6605360b11";
const index = "expo-index-02872ff9f2ca";
const unchanged = "expo-tabs-scan-index-2bbf42237cc6";
const open = async id => {
await page.goto(`${url}#/screens`);
const all = page.getByRole("button", { name: /^All/ }).first();
@@ -325,14 +333,14 @@ async function inspectorFrames(page, url) {
const swipeImage = page.locator(".sidebar-review-stage img").first();
await expect(swipeImage).toBeVisible();
const changed = await swipeImage.boundingBox();
await open(index);
await open(unchanged);
const single = page.locator(".sidebar-review-off .variant-preview");
await expect(single).toBeVisible();
return { changed, single: await single.boundingBox() };
}
test("the Inspector frames an unchanged screen at the size of a changed screen's Swipe frame", { timeout: 90_000 }, async t => {
// / is unchanged (not compared); /games is modified. The single frame used to take at most half the panel, the
// /scan is unchanged; /games is modified. The single frame used to take at most half the panel, the
// width of one frame of a Before/After pair, while Swipe and Flip fill the panel up to 70 % (phone: 52 %) of the window.
for (const viewport of [{ width: 1024, height: 820 }, { width: 390, height: 844 }]) {
const { page, url, errors } = await openReport(t, viewport);
+51 -20
View File
@@ -178,32 +178,63 @@ test.describe("Inspector resize", () => {
await expect.poll(() => panelWidth(page)).toBe(500);
});
test.describe("in a window too narrow for the toolbar beside a wide Inspector", () => {
test.describe("in a window too narrow for the toolbar beside a half-window Inspector", () => {
test.use({ viewport: { width: 820, height: 800 } });
test("the toolbar never moves past the canvas' left edge", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
/** The widest the panel may be here: the window less the bottom bar and a 12px gap either side. */
async function widestBesideToolbar(page: Page) {
const toolbarBox = (await page.getByRole("toolbar", { name: "Canvas tools" }).boundingBox())!;
return Math.floor(820 - (toolbarBox.width + 2 * 12));
}
async function expectToolbarBesidePanel(page: Page) {
const toolbar = page.getByRole("toolbar", { name: "Canvas tools" });
await expect(toolbar).toBeVisible();
await handle(page).focus();
await page.keyboard.press("End");
await expect.poll(() => panelWidth(page)).toBe(410);
// Either it fits between the window's edge and the panel, or it gives way, as it does when
// the panels leave the canvas too little room.
await expect.poll(async () => {
if (await toolbar.count() === 0) return true;
const toolbarBox = (await toolbar.boundingBox())!;
const panelBox = (await panel(page).boundingBox())!;
return toolbarBox.x >= 0 && toolbarBox.x + toolbarBox.width <= panelBox.x;
}).toBe(true);
// Narrowed again, the toolbar returns.
await page.keyboard.press("Home");
await expect(toolbar).toBeVisible();
await expect(toolbar.getByRole("button", { name: "More", exact: true })).toBeVisible();
const toolbarBox = (await toolbar.boundingBox())!;
const panelBox = (await panel(page).boundingBox())!;
expect(toolbarBox.x).toBeGreaterThanOrEqual(0);
expect(toolbarBox.x + toolbarBox.width + 12).toBeCloseTo(panelBox.x, 0);
expect(toolbarBox.x).toBeGreaterThanOrEqual(12 - 1);
expect(toolbarBox.x + toolbarBox.width + 12).toBeLessThanOrEqual(panelBox.x + 1);
}
test("End stops the Inspector where the toolbar still fits beside it, with More in reach", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
const widest = await widestBesideToolbar(page);
// Half the window would be 410; the toolbar needs more of the canvas than that leaves.
expect(widest).toBeLessThan(410);
expect(widest).toBeGreaterThan(320);
await expect(handle(page)).toHaveAttribute("aria-valuemax", String(widest));
await handle(page).focus();
await page.keyboard.press("End");
await expect.poll(() => panelWidth(page)).toBe(widest);
await expect(handle(page)).toHaveAttribute("aria-valuenow", String(widest));
await page.keyboard.press("ArrowLeft");
await expect.poll(() => panelWidth(page)).toBe(widest);
await expectToolbarBesidePanel(page);
// Narrowed again, the toolbar keeps its gap to the panel.
await page.keyboard.press("Home");
await expect.poll(() => panelWidth(page)).toBe(320);
await expectToolbarBesidePanel(page);
});
test("a drag or a saved width stops there too", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
const widest = await widestBesideToolbar(page);
await dragEdge(page, -300);
await expect.poll(() => panelWidth(page)).toBe(widest);
expect(await storedWidth(page)).toBe(String(widest));
await expectToolbarBesidePanel(page);
await page.evaluate((key) => localStorage.setItem(key, "800"), STORAGE_KEY);
await page.reload();
await expect(panel(page)).toBeVisible();
await expect.poll(() => panelWidth(page)).toBe(widest);
await expectToolbarBesidePanel(page);
// A wider window gives the saved width more room again.
await page.setViewportSize({ width: 1280, height: 800 });
await expect.poll(() => panelWidth(page)).toBe(640);
});
});
+411 -124
View File
@@ -197,15 +197,20 @@ async function expectMapSelectionRing(page: Page) {
await page.mouse.move(1, 1);
}
/** The camera chrome's theme button steps Auto → Dark → Light; press it until the page shows the option. */
/** Picks a theme in the bottom bar's More menu, then closes the menu. */
async function chooseTheme(page: Page, option: "light" | "dark") {
const root = page.locator("html");
for (let presses = 0; presses < 3; presses += 1) {
if (await root.getAttribute("data-theme") === option) return;
await page.getByRole("button", { name: "Toggle theme" }).click();
await page.waitForTimeout(50);
}
await expect(root).toHaveAttribute("data-theme", option);
await page.getByRole("button", { name: "More", exact: true }).click();
const menu = page.getByRole("menu", { name: "More" });
await menu.getByRole("menuitemradio", { name: option === "light" ? "Light" : "Dark", exact: true }).click();
await page.keyboard.press("Escape");
await expect(menu).toHaveCount(0);
await expect(page.locator("html")).toHaveAttribute("data-theme", option);
}
/** There is no button to bring the Inspector back; a selection, Return or I opens it. */
async function openInspector(page: Page) {
await page.keyboard.press("i");
await expect(page.locator(".right-panel")).toBeVisible();
}
/** Bottom toolbar → persistent canvas view control. */
@@ -1668,7 +1673,7 @@ test("collapses the Inspector when a screen is cleared but still allows an empty
await expect.poll(() => new URL(page.url()).searchParams.has("screen")).toBe(false);
await expect(page.locator(".right-panel")).toHaveCount(0);
await page.getByRole("button", { name: "Expand inspector" }).click();
await openInspector(page);
await expect(page.locator(".right-panel")).toBeVisible();
await expect.poll(() => new URL(page.url()).searchParams.has("screen")).toBe(false);
});
@@ -1854,13 +1859,12 @@ test("keeps persistent canvas chrome out of the sliding canvas snapshot", async
await page.setViewportSize({ width: 1600, height: 900 });
await page.goto("/map");
await expect(page.locator(".canvas-minimap-shell")).toBeVisible();
await expect(page.locator(".right-float")).toBeVisible();
await expect(page.locator(".app-content > .canvas-camera-controls")).toBeVisible();
const transitionNames = await page.locator([
".canvas-minimap-shell",
".app-content > .canvas-camera-controls",
".canvas-toolbar",
".right-float",
].join(",")).evaluateAll((elements) => elements.map((element) => ({
className: element.className,
viewTransitionName: getComputedStyle(element).viewTransitionName,
@@ -1869,7 +1873,6 @@ test("keeps persistent canvas chrome out of the sliding canvas snapshot", async
expect.objectContaining({ viewTransitionName: "canvas-minimap" }),
expect.objectContaining({ viewTransitionName: "canvas-camera-controls" }),
expect.objectContaining({ viewTransitionName: "canvas-toolbar" }),
expect.objectContaining({ viewTransitionName: "right-floating-controls" }),
]));
const animations = await captureCanvasViewAnimations(page, "Screens");
@@ -1890,7 +1893,6 @@ test("keeps persistent canvas chrome out of the sliding canvas snapshot", async
const movingPersistentChrome = animations.filter((animation) => (
animation.pseudoElement?.includes("(canvas-camera-controls)")
|| animation.pseudoElement?.includes("(canvas-toolbar)")
|| animation.pseudoElement?.includes("(right-floating-controls)")
));
expect(movingPersistentChrome).toEqual([]);
});
@@ -1916,7 +1918,7 @@ test("centres selected screens after panel changes and makes the primary Fit sel
await expectSelectedScreenCentered(page);
await expectPanelFitMatchesPrimaryFit(page, canvas);
await page.getByRole("button", { name: "Expand inspector" }).click();
await openInspector(page);
await expect(page.locator(".right-panel")).toBeVisible();
await expectSelectedScreenCentered(page);
await expectPanelFitMatchesPrimaryFit(page, canvas);
@@ -2255,7 +2257,7 @@ test("keeps current Map and Screens projections overlap-free without deleting sc
await expect(page).toHaveURL(/\/screens/);
await expect(page.locator(".screens-page .screens-cell")).toHaveCount(SCREEN_COUNT);
await expect.poll(() => overlapCount(".screens-page .screens-cell")).toBe(0);
await page.getByRole("button", { name: "Expand inspector" }).click();
await openInspector(page);
await expect(page.locator(".right-panel")).toBeVisible();
await expect.poll(() => overlapCount(".screens-page .screens-cell")).toBe(0);
});
@@ -2337,7 +2339,7 @@ test("shows the minimap on the Map without a visibility preference", async ({ pa
test("keeps minimap and canvas chrome inside the responsive visible frame", async ({ page }) => {
await page.setViewportSize({ width: 900, height: 820 });
await page.goto("/map");
await page.getByRole("button", { name: "Expand inspector" }).click();
await openInspector(page);
const minimap = page.getByTestId("canvas-minimap");
const toolbar = page.getByRole("toolbar", { name: "Canvas tools" });
@@ -2377,6 +2379,7 @@ test("keeps minimap and canvas chrome inside the responsive visible frame", asyn
const cameraBeforeTheme = await viewport.getAttribute("style");
const maskBeforePanel = await minimap.locator(".canvas-minimap-visible-mask path").getAttribute("d");
const lightBackground = await minimap.evaluate((element) => getComputedStyle(element).backgroundColor);
// The bar has moved clear of the Inspector, so its More menu is in reach.
await chooseTheme(page, "dark");
await expect(page.locator("html")).toHaveAttribute("data-theme", "dark");
await expect(viewport).toHaveAttribute("style", cameraBeforeTheme!);
@@ -2490,7 +2493,9 @@ test("animates panel Fits once in both directions", async ({ page }) => {
}).__panelFitCameraObserver = observer;
});
await page.getByRole("button", { name: buttonName, exact: true }).click();
// Closed, the Inspector has no button: I opens it.
if (buttonName === "Expand inspector") await page.keyboard.press("i");
else await page.getByRole("button", { name: buttonName, exact: true }).click();
await expectLayout();
await page.waitForTimeout(520);
const samples = await page.evaluate(() => {
@@ -2624,7 +2629,9 @@ test("refits every unselected canvas when the Inspector opens or closes", async
host.__overviewPanelCamera = { values, observer };
}, canvas);
await page.getByRole("button", { name: buttonName, exact: true }).click();
// Closed, the Inspector has no button: I opens it.
if (buttonName === "Expand inspector") await page.keyboard.press("i");
else await page.getByRole("button", { name: buttonName, exact: true }).click();
if (buttonName === "Expand inspector") {
await expect(page.locator(".right-panel")).toBeVisible();
} else {
@@ -2716,7 +2723,7 @@ test("starts the opening Inspector Fit immediately and settles in one flight", a
.__inspectorPaintSamples = samples;
});
await page.getByRole("button", { name: "Expand inspector" }).click();
await openInspector(page);
await expect(page.locator(".right-panel")).toBeVisible();
await page.waitForTimeout(600);
const samples = await page.evaluate(() => (
@@ -2758,47 +2765,41 @@ test("starts the opening Inspector Fit immediately and settles in one flight", a
expect(moving[0]!.elapsed - visible[0]!.elapsed).toBeLessThan(80);
});
test("aligns the pill, camera controls, and collapsed Inspector chrome on one center line", async ({ page }) => {
test("aligns the pill and the Map's camera controls on one center line, mirrored at the edges", async ({ page }) => {
await page.goto("/map?screen=settings-root");
await page.getByRole("button", { name: "Close inspector" }).click();
const pill = page.locator(".left-panel-collapsed-pill");
const camera = page.getByRole("group", { name: "Canvas camera controls" });
const inspector = page.locator(".right-float");
const share = camera.getByRole("button", { name: "Toggle theme", exact: true });
const fit = camera.getByRole("button", { name: "Fit canvas", exact: true });
await expect(pill).toBeVisible();
await expect(camera).toBeVisible();
await expect(inspector).toBeVisible();
// The closed Inspector leaves nothing behind in the top right.
await expect(page.getByRole("button", { name: "Expand inspector" })).toHaveCount(0);
const [pillBox, cameraBox, inspectorBox, shareBox] = await Promise.all([
const [pillBox, cameraBox, fitBox] = await Promise.all([
pill.boundingBox(),
camera.boundingBox(),
inspector.boundingBox(),
share.boundingBox(),
fit.boundingBox(),
]);
expect(pillBox).not.toBeNull();
expect(cameraBox).not.toBeNull();
expect(inspectorBox).not.toBeNull();
expect(shareBox).not.toBeNull();
expect(fitBox).not.toBeNull();
expect(Math.abs(pillBox!.y - 14)).toBeLessThanOrEqual(1);
expect(Math.abs(pillBox!.height - 42)).toBeLessThanOrEqual(1);
expect(Math.abs(cameraBox!.y - 14)).toBeLessThanOrEqual(1);
expect(Math.abs(cameraBox!.height - 42)).toBeLessThanOrEqual(1);
expect(Math.abs(inspectorBox!.y - 14)).toBeLessThanOrEqual(1);
expect(Math.abs(inspectorBox!.height - 42)).toBeLessThanOrEqual(1);
expect(Math.abs(shareBox!.height - 32)).toBeLessThanOrEqual(1);
const centerLine = cameraBox!.y + cameraBox!.height / 2;
for (const box of [pillBox!, inspectorBox!]) {
expect(Math.abs(box.y + box.height / 2 - centerLine)).toBeLessThanOrEqual(1);
}
expect(Math.abs(fitBox!.height - 32)).toBeLessThanOrEqual(1);
expect(Math.abs(pillBox!.y + pillBox!.height / 2 - (cameraBox!.y + cameraBox!.height / 2))).toBeLessThanOrEqual(1);
// The controls sit as far from the right edge as the pill does from the left.
expect(Math.abs(page.viewportSize()!.width - (cameraBox!.x + cameraBox!.width) - pillBox!.x)).toBeLessThanOrEqual(1);
});
test("floats the pill over the canvas and remembers the Inspector across a reload", async ({ page }) => {
await page.goto("/map");
await expect(page.locator(".right-panel")).toHaveCount(0);
await page.getByRole("button", { name: "Expand inspector" }).click();
await openInspector(page);
// The pill and the Inspector share one panel surface.
const expandedPanelBackground = await page.locator(".left-panel-collapsed-pill").evaluate(
(element) => getComputedStyle(element).backgroundColor,
@@ -2833,31 +2834,20 @@ test("floats the pill over the canvas and remembers the Inspector across a reloa
await page.getByRole("button", { name: "Close inspector" }).click();
await expect(page.locator(".right-panel")).toHaveCount(0);
const canvasActions = page.getByRole("toolbar", { name: "Canvas actions" });
const cameraControls = page.getByRole("group", { name: "Canvas camera controls" });
const canvasToolbar = page.getByRole("toolbar", { name: "Canvas tools" });
const minimap = page.getByTestId("canvas-minimap");
await expect(canvasActions).toBeVisible();
// Closed, the Inspector leaves no toolbar of its own; the camera controls stay one floating group.
await expect(page.getByRole("toolbar", { name: "Canvas actions" })).toHaveCount(0);
await expect(cameraControls).toBeVisible();
await expect(canvasToolbar).toBeVisible();
await expect(minimap).toBeVisible();
await expect(canvasActions).toHaveCSS("background-color", expandedPanelBackground);
await expect(cameraControls).toHaveCSS("background-color", expandedPanelBackground);
await expect(canvasActions).toHaveCSS("border-top-width", "0px");
await expect(cameraControls).toHaveCSS("border-top-width", "0px");
await expect(cameraControls.locator(".camera-control-divider").first()).toBeHidden();
const [actionsBox, cameraBox] = await Promise.all([
canvasActions.boundingBox(),
cameraControls.boundingBox(),
]);
expect(actionsBox).not.toBeNull();
expect(cameraBox).not.toBeNull();
const toolbarJoin = actionsBox!.x - (cameraBox!.x + cameraBox!.width);
expect(toolbarJoin).toBeGreaterThanOrEqual(-1.5);
expect(toolbarJoin).toBeLessThanOrEqual(0.5);
await expect(cameraControls).toHaveCSS("border-top-width", "1px");
await expect(cameraControls.locator(".camera-control-divider").first()).toBeVisible();
const [leftShadow, rightShadow, toolbarShadow, toolbarBox, minimapBox] = await Promise.all([
page.locator(".left-panel-collapsed-pill").evaluate((element) => getComputedStyle(element).boxShadow),
cameraControls.evaluate((element) => getComputedStyle(element, "::before").boxShadow),
cameraControls.evaluate((element) => getComputedStyle(element).boxShadow),
canvasToolbar.evaluate((element) => getComputedStyle(element).boxShadow),
canvasToolbar.boundingBox(),
minimap.boundingBox(),
@@ -2874,7 +2864,7 @@ test("floats the pill over the canvas and remembers the Inspector across a reloa
await page.reload();
await expect(page.locator(".left-panel.collapsed")).toBeVisible();
await expect(page.locator(".right-panel")).toHaveCount(0);
await page.getByRole("button", { name: "Expand inspector" }).click();
await openInspector(page);
await expect(page.locator(".right-panel")).toBeVisible();
});
@@ -2910,20 +2900,24 @@ test("keeps stateful shell control geometry stable across visual state changes",
expect(Math.abs(pillAlignment.logo - pillAlignment.pill)).toBeLessThanOrEqual(1);
expect(Math.abs(pillAlignment.name - pillAlignment.pill)).toBeLessThanOrEqual(1);
const rightClosed = await geometry(page.getByRole("button", { name: "Expand inspector" }));
await expect(page.getByRole("button", { name: "Expand inspector" })
.locator("svg.lucide-panel-right")).toHaveCount(1);
await page.getByRole("button", { name: "Expand inspector" }).click();
const rightOpen = await geometry(page.getByRole("button", { name: "Close inspector" }));
// Open, the same button shows an X that closes the Inspector.
// Closed, the Inspector has no button; open, an X closes it.
await expect(page.getByRole("button", { name: "Expand inspector" })).toHaveCount(0);
await openInspector(page);
await expect(page.getByRole("button", { name: "Close inspector" })
.locator("svg.lucide-x")).toHaveCount(1);
expect(rightOpen).toEqual(rightClosed);
const themeButton = page.getByRole("button", { name: "Toggle theme" });
const lightTheme = await geometry(themeButton);
await themeButton.click();
const darkTheme = await geometry(themeButton);
// The More button keeps its size whether its menu is open or not, and the theme switch keeps
// its size whichever theme is checked.
const more = page.getByRole("button", { name: "More", exact: true });
const moreClosed = await geometry(more);
await more.click();
const moreOpen = await geometry(more);
expect(moreOpen).toEqual(moreClosed);
const themes = page.getByRole("menu", { name: "More" }).getByRole("group", { name: "Theme" });
const lightTheme = await geometry(themes);
await themes.getByRole("menuitemradio", { name: "Dark", exact: true }).click();
await expect(page.locator("html")).toHaveAttribute("data-theme", "dark");
const darkTheme = await geometry(themes);
expect(darkTheme).toEqual(lightTheme);
});
@@ -2936,7 +2930,7 @@ test("migrates the legacy shared panel preference once into the Inspector prefer
right: localStorage.getItem("expo-explore:right-panel-collapsed"),
}))).toEqual({ legacy: null, right: "true" });
await page.getByRole("button", { name: "Expand inspector" }).click();
await openInspector(page);
await expect(page.locator(".right-panel")).toBeVisible();
});
@@ -3010,14 +3004,18 @@ test("drives the shell from the keyboard, and says so on hover", async ({ page }
// Every remaining shortcut is discoverable: the tooltip prints the key next to the label.
await compareButton.hover();
await expect(page.locator(".tooltip-key")).toHaveText("C");
await page.getByRole("button", { name: "Expand inspector" }).hover();
await expect(page.locator(".tooltip-key")).toHaveText("I");
// The theme button names the mode in force, and T is its key.
const themeButton = page.getByRole("button", { name: "Toggle theme" });
await themeButton.hover();
await expect(page.locator(".tooltip-content")).toContainText("Theme: Auto");
await expect(page.locator(".tooltip-key")).toHaveText("T");
await page.mouse.move(0, 0);
// The More menu's theme row checks the mode in force, and prints T as its key.
const themeChoice = async () => {
await page.getByRole("button", { name: "More", exact: true }).click();
const menu = page.getByRole("menu", { name: "More" });
await expect(menu.getByRole("group", { name: "Theme" }).locator("kbd")).toHaveText("T");
const checked = await menu.getByRole("menuitemradio", { checked: true }).getAttribute("aria-label");
await page.keyboard.press("Escape");
await expect(menu).toHaveCount(0);
return checked;
};
expect(await themeChoice()).toBe("Auto");
const initialTheme = await page.locator("html").getAttribute("data-theme");
expect(initialTheme === "light" || initialTheme === "dark").toBe(true);
const otherTheme = initialTheme === "dark" ? "light" : "dark";
@@ -3026,9 +3024,7 @@ test("drives the shell from the keyboard, and says so on hover", async ({ page }
await expect(page.locator("html")).toHaveAttribute("data-theme", otherTheme);
await page.keyboard.press("t");
await expect(page.locator("html")).toHaveAttribute("data-theme", initialTheme!);
await themeButton.hover();
await expect(page.locator(".tooltip-content")).toContainText(initialTheme === "dark" ? "Theme: Dark" : "Theme: Light");
await page.mouse.move(0, 0);
expect(await themeChoice()).toBe(initialTheme === "dark" ? "Dark" : "Light");
// The retired theme and inspector chords no longer answer.
await page.keyboard.press(`${mod}+Alt+t`);
await expect(page.locator("html")).toHaveAttribute("data-theme", initialTheme!);
@@ -3081,7 +3077,7 @@ test("keeps fixed objects and canvas pan after a reload", async ({ page }) => {
test("delays the first tooltip, then shows subsequent tooltips instantly", async ({ page }) => {
await page.goto("/map");
const menu = page.locator(".left-panel-collapsed-pill").getByRole("button", { name: "Map", exact: true });
const changes = page.getByRole("button", { name: "Expand inspector" });
const changes = page.getByRole("button", { name: "Fit canvas", exact: true });
const tooltip = page.locator(".tooltip");
await menu.hover();
@@ -3091,7 +3087,7 @@ test("delays the first tooltip, then shows subsequent tooltips instantly", async
await expect(tooltip).not.toHaveAttribute("data-instant", "");
await changes.hover();
await expect(tooltip).toContainText("Expand inspector", { timeout: 150 });
await expect(tooltip).toContainText("Fit canvas", { timeout: 150 });
await expect(tooltip).toHaveAttribute("data-instant", "");
await expect(tooltip).toHaveCSS("animation-name", "none");
@@ -3100,7 +3096,7 @@ test("delays the first tooltip, then shows subsequent tooltips instantly", async
await changes.hover();
await page.waitForTimeout(150);
await expect(tooltip).toHaveCount(0);
await expect(tooltip).toContainText("Expand inspector");
await expect(tooltip).toContainText("Fit canvas");
await expect(tooltip).not.toHaveAttribute("data-instant", "");
});
@@ -3129,9 +3125,10 @@ test("follows system theme and polls lightweight status instead of the full map"
await chooseTheme(page, "light");
await expect(page.locator("html")).toHaveAttribute("data-theme", "light");
expect(await page.evaluate(() => localStorage.getItem("expo-explore:theme"))).toBe("light");
// The button shows the mode in force (Light), not the next one.
await expect(page.getByRole("button", { name: "Toggle theme" })
.locator("svg.lucide-sun")).toBeVisible();
// The More menu checks the mode in force.
await page.getByRole("button", { name: "More", exact: true }).click();
await expect(page.getByRole("menuitemradio", { name: "Light", exact: true })).toHaveAttribute("aria-checked", "true");
await page.keyboard.press("Escape");
await page.waitForTimeout(5_500);
expect(mapRequests).toBe(1);
@@ -3150,11 +3147,30 @@ test("Screens adds the screens a live map gains", async ({ page }) => {
await expect(page.locator(".screens-page .screens-cell")).toHaveCount(30, { timeout: 7_000 });
});
test("a local map keeps a screen whose capture gap was accepted on its Map, in Screens and in find", async ({ page }) => {
// A public report leaves such a route out (omitted-screens.ts); a local run's screens are all its own.
const payload = await liveMapPayload(3, 100);
payload.map.gaps.push({ id: "accepted", screenId: "live-screen-2", kind: "coverage", status: "accepted",
message: "Redirect declaration; no screenshot selected", createdAt: payload.map.run.createdAt });
await serveMap(page, payload);
await page.goto("/map");
await expect(page.locator(".react-flow__node-screen")).toHaveCount(3);
await page.goto("/screens");
await expect(page.locator(".screens-page .screens-cell")).toHaveCount(3);
await expect(page.locator('.screens-page .screens-tree-row[data-screen-id="live-screen-2"]')).toHaveCount(1);
await page.keyboard.press("/");
const field = page.getByRole("main", { name: "Screens" }).getByRole("searchbox", { name: "Find screens" });
await expect(field).toBeFocused();
await field.fill("screen 2");
await expect(page.locator(".screens-page .screens-cell")).toHaveCount(1);
await expect(page.locator('.screens-page .screens-cell[data-screen-id="live-screen-2"]')).toHaveCount(1);
});
test("zooms Map inspection up to 25600% without exceeding the ceiling", async ({ page }) => {
test.setTimeout(30_000);
await page.goto("/map");
await expect(page.locator(".map-canvas.canvas-projection-animating")).toHaveCount(0);
await expect(page.locator(".right-float")).toBeVisible();
await expect(page.getByRole("group", { name: "Canvas camera controls" })).toBeVisible();
await page.keyboard.press("Shift+0");
await expect(page.getByRole("button", { name: "Zoom — 100%" })).toBeVisible();
@@ -3175,10 +3191,11 @@ test("zooms Map inspection up to 25600% without exceeding the ceiling", async ({
await expect(zoom).toBeVisible();
expect(scaleFromTransform(await viewport.getAttribute("style"))).toBe(256);
const zoomBox = await zoom.boundingBox();
const shareBox = await page.locator(".right-float").boundingBox();
const cameraBox = await page.getByRole("group", { name: "Canvas camera controls" }).boundingBox();
expect(zoomBox).not.toBeNull();
expect(shareBox).not.toBeNull();
expect(zoomBox!.x + zoomBox!.width).toBeLessThanOrEqual(shareBox!.x);
expect(cameraBox).not.toBeNull();
expect(zoomBox!.x + zoomBox!.width).toBeLessThanOrEqual(cameraBox!.x + cameraBox!.width);
expect(cameraBox!.x + cameraBox!.width).toBeLessThanOrEqual(page.viewportSize()!.width);
await page.keyboard.press("Shift+0");
await expect(page.getByRole("button", { name: "Zoom — 100%" })).toBeVisible();
@@ -3482,15 +3499,13 @@ test("restores the fitted camera after internal navigation on the Map", async ({
});
});
test("keeps theme and full screen in the persistent canvas controls, not the inspector header", async ({ page }) => {
test("the Map's top right holds only fit, center and zoom; theme and full screen are not in the inspector header", async ({ page }) => {
await page.goto("/map");
// Collapsed inspector: the camera controls and the panel toggle form one toolbar.
// Closed, the Inspector leaves no toggle behind: the camera controls are all there is.
const collapsedCamera = page.getByRole("group", { name: "Canvas camera controls" });
await expect(collapsedCamera.getByRole("button", { name: "Toggle theme", exact: true })).toBeVisible();
await expect(collapsedCamera.getByRole("button", { name: "Enter full screen", exact: true })).toBeVisible();
await expect(page.locator(".right-float button")).toHaveCount(1);
await expect(page.locator(".right-float button")).toHaveAccessibleName("Expand inspector");
await page.getByRole("button", { name: "Expand inspector" }).click();
await expect(collapsedCamera.getByRole("button")).toHaveCount(3);
await expect(page.getByRole("button", { name: "Expand inspector" })).toHaveCount(0);
await openInspector(page);
await expect(page.getByRole("button", { name: /Share/ })).toHaveCount(0);
await expect(page.locator(".right-head button")).toHaveCount(1);
await expect(page.locator(".right-head button")).toHaveAccessibleName("Close inspector");
@@ -3508,18 +3523,19 @@ test("keeps theme and full screen in the persistent canvas controls, not the ins
await expect(cameraControls).toBeVisible();
await expect(cameraControls).not.toHaveCSS("background-color", "rgba(0, 0, 0, 0)");
await expect(cameraControls).toHaveCSS("border-top-width", "1px");
await expect(cameraControls.locator(".camera-control-divider")).toHaveCount(3);
await expect(cameraControls.locator(".camera-control-divider")).toHaveCount(1);
const cameraButtons = cameraControls.getByRole("button");
await expect(cameraButtons).toHaveCount(5);
await expect(cameraButtons.nth(3)).toHaveAccessibleName("Toggle theme");
await expect(cameraButtons.nth(4)).toHaveAccessibleName("Enter full screen");
await expect(cameraButtons).toHaveCount(3);
await expect(cameraButtons.nth(0)).toHaveAccessibleName("Fit canvas");
await expect(cameraButtons.nth(1)).toHaveAccessibleName("Center canvas");
await expect(cameraButtons.nth(2)).toHaveAccessibleName(/^Zoom — /);
await expect(page.getByRole("button", { name: /Toggle theme|full screen/ })).toHaveCount(0);
for (const button of await cameraButtons.all()) {
await expect(button).toHaveCSS("border-top-width", "0px");
await expect(button).toHaveCSS("background-color", "rgba(0, 0, 0, 0)");
}
await expect(page.locator(".app-content > .canvas-camera-controls")).toHaveCount(1);
await expect(page.locator(".right-panel .canvas-camera-controls, .right-float .canvas-camera-controls"))
.toHaveCount(0);
await expect(page.locator(".right-panel .canvas-camera-controls")).toHaveCount(0);
const zoomButton = cameraControls.getByRole("button", { name: /^Zoom — / });
await expect(zoomButton).toBeVisible();
await expect(zoomButton.locator("svg")).toHaveCount(0);
@@ -3573,11 +3589,10 @@ test("keeps theme and full screen in the persistent canvas controls, not the ins
await expect.poll(async () => scaleFromTransform(await viewport.getAttribute("style")))
.toBeCloseTo(pannedScale, 6);
// The theme toggle changes the page theme without changing the route.
// The theme changes the page theme without changing the route.
const canonical = page.url();
const themeBefore = await page.locator("html").getAttribute("data-theme");
await cameraControls.getByRole("button", { name: "Toggle theme", exact: true }).click();
await expect(page.locator("html")).not.toHaveAttribute("data-theme", themeBefore!);
await chooseTheme(page, themeBefore === "dark" ? "light" : "dark");
await expect(page).toHaveURL(canonical);
await expect(page.getByRole("dialog")).toHaveCount(0);
@@ -4089,10 +4104,10 @@ test("reload max-fits the comparison overview with the Inspector collapsed", asy
await page.setViewportSize({ width: 1600, height: 900 });
await page.goto("/map");
await expect(page.locator(".react-flow__node-screen")).toHaveCount(SCREEN_COUNT);
await expect(page.getByRole("button", { name: "Expand inspector" })).toBeVisible();
await expect(page.locator(".right-panel")).toHaveCount(0);
await page.reload();
await expect(page.locator(".react-flow__node-screen")).toHaveCount(SCREEN_COUNT);
await expect(page.getByRole("button", { name: "Expand inspector" })).toBeVisible();
await expect(page.locator(".right-panel")).toHaveCount(0);
const viewport = page.locator(".map-canvas .react-flow__viewport");
await expect(viewport).toBeVisible();
@@ -4686,10 +4701,10 @@ test.describe("phone layout", () => {
await page.goto("/map");
const tabs = page.getByRole("navigation", { name: "Views" });
await expect(tabs).toBeVisible();
// Desktop chrome is gone: the floating toolbar with its shortcuts button, the camera controls
// and the minimap.
// Desktop chrome is gone: the floating toolbar with its More menu, the camera controls and the
// minimap.
await expect(page.getByRole("toolbar", { name: "Canvas tools" })).toHaveCount(0);
await expect(page.getByRole("button", { name: "Keyboard shortcuts" })).toHaveCount(0);
await expect(page.getByRole("button", { name: "More", exact: true })).toHaveCount(0);
await expect(page.locator(".canvas-camera-controls")).toHaveCount(0);
await expect(tabs.getByRole("button", { name: /Compare/ })).toBeEnabled();
@@ -5204,40 +5219,312 @@ test.describe("phone layout", () => {
});
});
test("the theme is Auto until the toggle picks one: it follows the system, then steps Dark → Light → Auto and keeps the pick", async ({ page }) => {
test("the theme is Auto until the More menu picks one: it follows the system, and a pick outlives a reload", async ({ page }) => {
await page.emulateMedia({ colorScheme: "dark" });
await page.goto("/map");
const html = page.locator("html");
const button = page.getByRole("button", { name: "Toggle theme" });
const more = page.getByRole("button", { name: "More", exact: true });
const menu = page.getByRole("menu", { name: "More" });
const theme = (name: "Auto" | "Light" | "Dark") => menu.getByRole("menuitemradio", { name, exact: true });
await expect(html).toHaveAttribute("data-theme", "dark");
await expect(button).toHaveAttribute("data-theme-preference", "system");
await button.hover();
await expect(page.locator(".tooltip-content")).toContainText("Theme: Auto (system)");
await more.click();
await expect(theme("Auto")).toHaveAttribute("aria-checked", "true");
// Auto tracks the system while it is in force.
await page.emulateMedia({ colorScheme: "light" });
await expect(html).toHaveAttribute("data-theme", "light");
await button.click();
// A pick applies at once and keeps the menu open, so the switch shows it.
await theme("Dark").click();
await expect(html).toHaveAttribute("data-theme", "dark");
await expect(button).toHaveAttribute("data-theme-preference", "dark");
await expect(page.locator(".tooltip-content")).toContainText("Theme: Dark");
await button.click();
await expect(theme("Dark")).toHaveAttribute("aria-checked", "true");
await expect(theme("Auto")).toHaveAttribute("aria-checked", "false");
await theme("Light").click();
await expect(html).toHaveAttribute("data-theme", "light");
await expect(button).toHaveAttribute("data-theme-preference", "light");
await button.click();
await expect(button).toHaveAttribute("data-theme-preference", "system");
await theme("Auto").click();
await expect(theme("Auto")).toHaveAttribute("aria-checked", "true");
await expect(html).toHaveAttribute("data-theme", "light");
await page.emulateMedia({ colorScheme: "dark" });
await expect(html).toHaveAttribute("data-theme", "dark");
// A picked theme outlives a reload and ignores the system.
await button.click();
await expect(button).toHaveAttribute("data-theme-preference", "dark");
await button.click();
await expect(button).toHaveAttribute("data-theme-preference", "light");
await theme("Light").click();
await page.keyboard.press("Escape");
await page.reload();
await expect(html).toHaveAttribute("data-theme", "light");
await expect(page.getByRole("button", { name: "Toggle theme" })).toHaveAttribute("data-theme-preference", "light");
await page.getByRole("button", { name: "More", exact: true }).click();
await expect(theme("Light")).toHaveAttribute("aria-checked", "true");
});
/** Stands in for the browser's full screen, which headless Chromium cannot enter, and records the calls. */
async function stubFullscreen(page: Page) {
await page.addInitScript(() => {
const host = window as typeof window & { __fullscreenCalls: string[] };
host.__fullscreenCalls = [];
let element: Element | null = null;
Object.defineProperty(Document.prototype, "fullscreenElement", { configurable: true, get: () => element });
Element.prototype.requestFullscreen = function requestFullscreen() {
host.__fullscreenCalls.push("enter");
element = document.documentElement;
document.dispatchEvent(new Event("fullscreenchange"));
return Promise.resolve();
};
Document.prototype.exitFullscreen = function exitFullscreen() {
host.__fullscreenCalls.push("exit");
element = null;
document.dispatchEvent(new Event("fullscreenchange"));
return Promise.resolve();
};
});
}
function fullscreenCalls(page: Page) {
return page.evaluate(() => (window as typeof window & { __fullscreenCalls: string[] }).__fullscreenCalls);
}
/** The visible buttons in the window's top-right corner, where the camera controls sit on the Map. */
async function topRightButtons(page: Page) {
return page.evaluate(() => [...document.querySelectorAll<HTMLElement>("button, [role='button']")]
.filter((element) => {
const box = element.getBoundingClientRect();
if (box.width === 0 || box.height === 0 || getComputedStyle(element).visibility === "hidden") return false;
return box.bottom <= 80 && box.right >= window.innerWidth - 240;
})
.map((element) => element.getAttribute("aria-label") ?? element.textContent?.trim() ?? ""));
}
test("the bottom bar's More menu holds the theme, full screen and keyboard shortcuts, each with its key", async ({ page }) => {
await stubFullscreen(page);
await page.emulateMedia({ colorScheme: "light" });
await page.goto("/map");
const toolbar = page.getByRole("toolbar", { name: "Canvas tools" });
const more = toolbar.getByRole("button", { name: "More", exact: true });
// The keyboard button became More; it is the bar's last button.
await expect(toolbar.getByRole("button", { name: "Keyboard shortcuts" })).toHaveCount(0);
await expect(toolbar.getByRole("button").last()).toHaveAccessibleName("More");
await expect(more).toHaveAttribute("aria-haspopup", "menu");
await expect(more).toHaveAttribute("aria-expanded", "false");
await more.click();
const menu = page.getByRole("menu", { name: "More" });
await expect(menu).toBeVisible();
await expect(more).toHaveAttribute("aria-expanded", "true");
// It opens above the bar, anchored to the button.
const [menuBox, moreBox, toolbarBox] = await Promise.all([menu.boundingBox(), more.boundingBox(), toolbar.boundingBox()]);
expect(menuBox!.y + menuBox!.height).toBeLessThan(toolbarBox!.y);
expect(Math.abs(menuBox!.x + menuBox!.width - (moreBox!.x + moreBox!.width))).toBeLessThanOrEqual(2);
// Rows: Theme (a group of three radio items), Full screen, Keyboard shortcuts, in sentence case.
const themes = menu.getByRole("group", { name: "Theme" });
expect(await themes.getByRole("menuitemradio").evaluateAll((items) => items.map((item) => item.getAttribute("aria-label"))))
.toEqual(["Auto", "Light", "Dark"]);
await expect(menu.getByRole("menuitem")).toHaveCount(2);
await expect(menu.getByRole("menuitem").nth(0)).toHaveAccessibleName("Full screen");
await expect(menu.getByRole("menuitem").nth(1)).toHaveAccessibleName("Keyboard shortcuts");
await expect(menu.getByRole("menuitemcheckbox")).toHaveAccessibleName("Inspector");
await expect(menu.locator(".more-menu-label")).toHaveText(["Theme", "Full screen", "Inspector", "Keyboard shortcuts"]);
await expect(menu.locator("kbd")).toHaveText(["T", "F", "I", "?"]);
for (const label of await menu.locator(".more-menu-label").all()) {
await expect(label).toHaveCSS("text-transform", "none");
}
// It opens on the current theme; the arrows walk the rows and the switch, Esc closes it and
// returns focus to More.
await expect(themes.getByRole("menuitemradio", { name: "Auto" })).toBeFocused();
await expect(themes.getByRole("menuitemradio", { name: "Auto" })).toHaveAttribute("aria-checked", "true");
await page.keyboard.press("ArrowRight");
await expect(themes.getByRole("menuitemradio", { name: "Light" })).toBeFocused();
await page.keyboard.press("ArrowDown");
await expect(menu.getByRole("menuitem", { name: "Full screen" })).toBeFocused();
await page.keyboard.press("ArrowDown");
await expect(menu.getByRole("menuitemcheckbox", { name: "Inspector" })).toBeFocused();
await page.keyboard.press("ArrowDown");
await expect(menu.getByRole("menuitem", { name: "Keyboard shortcuts" })).toBeFocused();
await page.keyboard.press("ArrowDown");
await expect(themes.getByRole("menuitemradio", { name: "Auto" })).toBeFocused();
await page.keyboard.press("Escape");
await expect(menu).toHaveCount(0);
await expect(more).toBeFocused();
await expect(more).toHaveAttribute("aria-expanded", "false");
// The switch sets the theme and keeps the menu open; T still flips it, and the switch follows.
await more.click();
await themes.getByRole("menuitemradio", { name: "Dark" }).click();
await expect(page.locator("html")).toHaveAttribute("data-theme", "dark");
await expect(themes.getByRole("menuitemradio", { name: "Dark" })).toHaveAttribute("aria-checked", "true");
await expect(menu).toBeVisible();
await page.keyboard.press("t");
await expect(page.locator("html")).toHaveAttribute("data-theme", "light");
await expect(themes.getByRole("menuitemradio", { name: "Light" })).toHaveAttribute("aria-checked", "true");
// Full screen: the row enters it and closes the menu; the row then offers the way out.
await menu.getByRole("menuitem", { name: "Full screen" }).click();
await expect(menu).toHaveCount(0);
expect(await fullscreenCalls(page)).toEqual(["enter"]);
await more.click();
await expect(menu.getByRole("menuitem", { name: "Exit full screen" })).toBeVisible();
await page.keyboard.press("Escape");
// F is the same toggle from the keyboard.
await page.keyboard.press("f");
expect(await fullscreenCalls(page)).toEqual(["enter", "exit"]);
await page.keyboard.press("f");
expect(await fullscreenCalls(page)).toEqual(["enter", "exit", "enter"]);
await more.click();
await expect(menu.getByRole("menuitem", { name: "Exit full screen" })).toBeVisible();
await page.keyboard.press("Escape");
await page.keyboard.press("f");
// Keyboard shortcuts opens the reference, which lists F.
await more.click();
await menu.getByRole("menuitem", { name: "Keyboard shortcuts" }).click();
await expect(menu).toHaveCount(0);
const dialog = page.getByRole("dialog", { name: "Keyboard shortcuts" });
await expect(dialog).toBeVisible();
await expect(dialog.locator(".shortcuts-row", { hasText: "Enter or exit full screen" }).locator("kbd")).toHaveText("F");
await page.keyboard.press("Escape");
await expect(dialog).toHaveCount(0);
// ? still opens it too.
await page.keyboard.press("?");
await expect(dialog).toBeVisible();
});
for (const [setup, withoutFullscreen] of [
// iPhone Safari has no element full screen.
["no element full screen", async (page: Page) => page.addInitScript(() => {
delete (Element.prototype as Partial<Element>).requestFullscreen;
})],
// A frame not allowed full screen (an embedded Viewer) has the method, but every request fails.
["a frame without full screen", async (page: Page) => {
await stubFullscreen(page);
await page.addInitScript(() => {
Object.defineProperty(Document.prototype, "fullscreenEnabled", { configurable: true, get: () => false });
});
}],
] as const) {
test(`without the browser's full screen (${setup}), the More menu, F and the shortcuts leave it out`, async ({ page }) => {
await withoutFullscreen(page);
await page.goto("/map");
await page.getByRole("button", { name: "More", exact: true }).click();
const menu = page.getByRole("menu", { name: "More" });
await expect(menu.getByRole("menuitem")).toHaveCount(1);
await expect(menu.getByRole("menuitem", { name: /full screen/i })).toHaveCount(0);
await expect(menu.locator("kbd")).toHaveText(["T", "I", "?"]);
await page.keyboard.press("Escape");
await page.keyboard.press("f");
expect(await page.evaluate(() => (window as typeof window & { __fullscreenCalls?: string[] }).__fullscreenCalls ?? [])).toEqual([]);
await page.keyboard.press("?");
await expect(page.getByRole("dialog", { name: "Keyboard shortcuts" })).not.toContainText("full screen");
});
}
test("the More menu's keys are its own: on Compare, ← → step no screen behind it, and ? hands focus back to More", async ({ page }) => {
await page.setViewportSize({ width: 1440, height: 860 });
await serveWorkspace(page);
await page.goto("/compare?screen=current-profile");
const compare = page.locator(".compare-section");
const route = compare.locator(".compare-bar .compare-nav-route");
await expect(route).toHaveText("/current-profile");
const more = page.getByRole("button", { name: "More", exact: true });
const menu = page.getByRole("menu", { name: "More" });
// Compare has no Inspector, so the menu leaves its row out.
await more.click();
await expect(menu.getByRole("menuitemcheckbox", { name: "Inspector" })).toHaveCount(0);
// ← and → on a row that is not the theme switch do nothing, and step no screen behind the menu.
await page.keyboard.press("ArrowDown");
await expect(menu.getByRole("menuitem").first()).toBeFocused();
await page.keyboard.press("ArrowRight");
await page.keyboard.press("ArrowLeft");
await page.keyboard.press("ArrowRight");
await expect(menu).toBeVisible();
await expect(route).toHaveText("/current-profile");
await expect(page).toHaveURL(/screen=current-profile/);
await page.keyboard.press("Escape");
await expect(menu).toHaveCount(0);
// ? opens the shortcuts as the row does; closing them returns focus to More.
await more.click();
await page.keyboard.press("?");
const dialog = page.getByRole("dialog", { name: "Keyboard shortcuts" });
await expect(dialog).toBeVisible();
await expect(menu).toHaveCount(0);
await page.keyboard.press("Escape");
await expect(dialog).toHaveCount(0);
await expect(more).toBeFocused();
});
test("with nothing selected, the More menu's Inspector row opens the Inspector, and the open menu follows the bar it moves", async ({ page }) => {
await page.setViewportSize({ width: 1000, height: 820 });
await page.goto("/map");
const more = page.getByRole("button", { name: "More", exact: true });
const menu = page.getByRole("menu", { name: "More" });
const inspector = page.locator(".right-panel");
await expect(inspector).toHaveCount(0);
await more.click();
const row = menu.getByRole("menuitemcheckbox", { name: "Inspector" });
await expect(row).toHaveAttribute("aria-checked", "false");
await expect(row).toHaveAttribute("aria-keyshortcuts", "I");
await row.click();
await expect(menu).toHaveCount(0);
await expect(inspector).toBeVisible();
await more.click();
await expect(row).toHaveAttribute("aria-checked", "true");
await row.click();
await expect(inspector).toHaveCount(0);
// I opens the Inspector with the menu up; the bar moves left out of its way, and the menu with it.
await more.click();
await expect(menu).toBeVisible();
const before = (await more.boundingBox())!;
await page.keyboard.press("i");
await expect(inspector).toBeVisible();
await expect.poll(async () => (await more.boundingBox())!.x).toBeLessThan(before.x - 1);
await expect(menu).toBeVisible();
await expect.poll(async () => {
const [menuBox, moreBox] = await Promise.all([menu.boundingBox(), more.boundingBox()]);
return Math.abs(menuBox!.x + menuBox!.width - (moreBox!.x + moreBox!.width));
}).toBeLessThanOrEqual(2);
});
test("in a window too short for it, the More menu scrolls", async ({ page }) => {
await page.setViewportSize({ width: 1180, height: 150 });
await page.goto("/map");
await page.getByRole("button", { name: "More", exact: true }).click();
const popover = page.locator(".menu-popover.more-menu");
await expect(popover).toBeVisible();
expect(await popover.evaluate((element) => element.scrollHeight > element.clientHeight)).toBe(true);
const box = (await popover.boundingBox())!;
expect(box.y + box.height).toBeLessThanOrEqual(150);
await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
await page.mouse.wheel(0, 200);
await expect.poll(() => popover.evaluate((element) => element.scrollTop)).toBeGreaterThan(0);
await expect(page.getByRole("menu", { name: "More" }).getByRole("menuitem", { name: "Keyboard shortcuts" })).toBeInViewport({ ratio: 1 });
});
test("the top right is the camera's alone: fit, center and zoom on the Map, nothing on Screens or Compare", async ({ page }) => {
await page.setViewportSize({ width: 1440, height: 900 });
await serveWorkspace(page);
await page.goto("/map");
const camera = page.getByRole("group", { name: "Canvas camera controls" });
await expect(camera).toBeVisible();
expect(await topRightButtons(page)).toEqual(["Fit canvas", "Center canvas", expect.stringMatching(/^Zoom — \d+%$/)]);
// With the Inspector open the camera keeps to the canvas beside it; the Inspector's header has
// only its own actions.
await openInspector(page);
await expect(camera.getByRole("button")).toHaveCount(3);
await page.getByRole("button", { name: "Close inspector" }).click();
await expect(page.locator(".right-panel")).toHaveCount(0);
await chooseCanvasView(page, "Screens");
await expect(page).toHaveURL(/\/screens/);
await expect(page.locator(".screens-page .screens-cell").first()).toBeVisible();
await expect(page.locator(".canvas-camera-controls")).toHaveCount(0);
expect(await topRightButtons(page)).toEqual([]);
await page.goto("/compare?screen=current-profile");
await expect(page.getByRole("region", { name: /^Compare / })).toBeVisible();
await expect(page.locator(".canvas-camera-controls")).toHaveCount(0);
expect(await topRightButtons(page)).toEqual([]);
});
test("/ finds screens on the Screens page: the tree and the grid narrow to the query, Enter picks the first match, Esc clears then closes", async ({ page }) => {
+10
View File
@@ -17,6 +17,16 @@ test("the bounds are in the panel's own pixels when the chrome is zoomed", () =>
assert.deepEqual(inspectorWidthBounds(1600, 0), inspectorWidthBounds(1600, 1));
});
test("the Inspector stops where the canvas keeps the bottom bar's room, never below the minimum", () => {
// 820 - 424 leaves 396, less than half of 820.
assert.deepEqual(inspectorWidthBounds(820, 1, 424), { min: INSPECTOR_WIDTH_MIN, max: 396 });
// In a wide window half of it is the tighter cap.
assert.deepEqual(inspectorWidthBounds(1440, 1, 424), { min: INSPECTOR_WIDTH_MIN, max: 720 });
// The room is in window pixels, the width in the panel's own: (1000 - 530) / 1.25 = 376.
assert.deepEqual(inspectorWidthBounds(1000, 1.25, 530), { min: INSPECTOR_WIDTH_MIN, max: 376 });
assert.deepEqual(inspectorWidthBounds(700, 1, 424), { min: INSPECTOR_WIDTH_MIN, max: INSPECTOR_WIDTH_MIN });
});
test("a width is clamped to the bounds and rounded to whole pixels", () => {
const bounds = { min: 320, max: 720 };
assert.equal(clampInspectorWidth(100, bounds), 320);
+13
View File
@@ -796,3 +796,16 @@ test('an excluded route is neither listed nor counted as an app-wide screen', ()
const body = renderPublicComment(state({ review: review([...evidenceReview().surfaces, excluded]) }));
assert.doesNotMatch(body, /\/channel|App-wide source changes|not compared/);
});
test('an excluded route that is new is not one of the changed screens, nor of the ones the list links to', () => {
const screens = Array.from({ length: 11 }, (_, index) => surface(`screen-${index}`, 'modified', { extra: {
review: { status: 'modified', description: `Changed ${index}` },
visual: { verdict: 'modified', reason: 'repeated-cross-build-delta', mismatchPercentage: 1, threshold: 0.1, tool: '[email protected]' },
} }));
const excluded = surface('channel', 'added', { route: '/c/[channel]', extra: { excluded: true } });
for (const key of ['baseImage', 'headImage', 'baseOutcome', 'headOutcome']) delete excluded[key];
const body = renderPublicComment(state({ review: review([...screens, excluded]) }));
assert.equal(titleOf(body), `### 11 screens changed · [Review in Explore](<${reportUrl}>)`);
assert.equal(listOf(body).at(-1), `- [1 more screen in the report](<${reportUrl}>)`);
assert.doesNotMatch(body, /\/c\/\[channel\]/);
});
+162 -7
View File
@@ -13,6 +13,13 @@ const { presentScreensByPath, presentBuildDiff } = await tsImport(
const { artifactUrl, indexMap } = await tsImport("../../viewer/src/utils/model.ts", import.meta.url);
const { primaryScreenshotForScreen } = await tsImport("../../viewer/src/utils/screen-images.ts", import.meta.url);
const { buildObservedGraph, buildViewerGraph, projectFullGraph } = await tsImport("../../viewer/src/utils/graph-model.ts", import.meta.url);
const { omittedScreenIds, omittedSourceScreenIds, reportScreens, withoutOmittedScreens } = await tsImport("../../viewer/src/utils/omitted-screens.ts", import.meta.url);
const { reviewChanges } = await import("../../dist/report/pr-comment-body.js");
const { neverCapturedSurfaceIds } = await tsImport("../../src/contracts/surface-capture.ts", import.meta.url);
const { buildSearchItems } = await tsImport("../../viewer/src/utils/search.ts", import.meta.url);
/** The Map as the Viewer draws a map without a comparison: its own screens, less the ones it never captured. */
const viewerGraph = (map, index = indexMap(map)) => buildViewerGraph(map, index, omittedScreenIds(map));
function entry(id, route, variant = "default", extra = {}) {
return {
@@ -124,10 +131,10 @@ test("source navigation projects directional context and route variants without
assert.equal(payload.coverage.transitions, 0);
for (const collection of ["transitions", "actionAttempts", "journeys"]) assert.deepEqual(payload.map[collection], []);
assert.equal(buildObservedGraph(payload.map, indexMap(payload.map)).groups.length, 0);
const viewerGraph = buildViewerGraph(payload.map, indexMap(payload.map));
assert.deepEqual(viewerGraph.screens.map(screen => screen.id).sort(), ["camera-alias", "games-free", "games-pro", "scan-breed", "scan-mood"]);
assert.equal(viewerGraph.groups.length, 2);
assert.ok(viewerGraph.groups.every(group => group.transitionIds.length === 0 && group.sourceEdges.length > 0));
const graph = viewerGraph(payload.map);
assert.deepEqual(graph.screens.map(screen => screen.id).sort(), ["camera-alias", "games-free", "games-pro", "scan-breed", "scan-mood"]);
assert.equal(graph.groups.length, 2);
assert.ok(graph.groups.every(group => group.transitionIds.length === 0 && group.sourceEdges.length > 0));
const presentation = presentScreensByPath(payload.map);
const scan = presentation.map.screens.find(screen => screen.route === "/scan/instruction");
assert.equal(scan.variantIds.length, 2);
@@ -139,7 +146,7 @@ test("source navigation projects directional context and route variants without
test("public map omits redirects and unselected changes routes while retaining selected failures", () => {
const review = verifyImages(fixture("changes"));
const current = workspaceSides(publicReviewToWorkspace(review)).current;
const graph = buildViewerGraph(current.map, indexMap(current.map));
const graph = viewerGraph(current.map);
assert.deepEqual(graph.screens.map(screen => screen.id).sort(), ["care-guide", "games-free"]);
assert.equal(current.map.screens.length, 7, "the published source inventory remains available");
@@ -149,7 +156,7 @@ test("public map omits redirects and unselected changes routes while retaining s
status: "failed", attempts: 1, landing: "unverified", reason: "Capture failed",
};
const failedMap = workspaceSides(publicReviewToWorkspace(failed)).current.map;
const failedGraph = buildViewerGraph(failedMap, indexMap(failedMap));
const failedGraph = viewerGraph(failedMap);
assert.equal(failedGraph.screens.some(screen => screen.id === "scan-mood"), true);
assert.equal(failedGraph.screens.some(screen => screen.id === "home"), false);
});
@@ -833,7 +840,7 @@ test("an excluded route leaves the map with an accepted gap, like a redirect", (
excluded.excluded = true;
for (const side of ["base", "head"]) { delete excluded[`${side}Image`]; delete excluded[`${side}Outcome`]; }
const { current } = workspaceSides(publicReviewToWorkspace(review));
const graph = buildViewerGraph(current.map, indexMap(current.map));
const graph = viewerGraph(current.map);
assert.equal(graph.screens.some(screen => screen.id === "games-pro"), false, "never captured, so not a card on the map");
assert.ok(current.map.screens.some(screen => screen.id === "games-pro"), "the inventory still knows the route");
const gap = current.map.gaps.find(gap => gap.screenId === "games-pro");
@@ -885,3 +892,151 @@ test("a screen's note is its first open gap of any kind, and an accepted gap onl
assert.equal(indexMap({ ...current.map, gaps: [resolved, accepted] }).screenNotes.get("games-free"), accepted.message);
assert.equal(indexMap({ ...current.map, gaps: [resolved] }).screenNotes.has("games-free"), false);
});
/** What the Viewer leaves out of a review and the comparison it then shows, computed as app.tsx does. */
function viewerOmission(review) {
const workspace = publicReviewToWorkspace(review);
const diff = diffFor(review);
const presentation = presentScreensByPath(diff.map);
const omitted = omittedScreenIds(diff.map, { diff, presentation });
const presented = presentBuildDiff(diff, presentation);
// The surfaces the Viewer leaves out, before path grouping: a removed screen goes back to its surface id.
const removed = new Map(review.surfaces.map(surface => [removedScreenId(workspace.catalog.defaultBaselineBuildId, surface.id), surface.id]));
const surfaces = new Set([...omittedSourceScreenIds(diff.map, diff)].map(id => removed.get(id) ?? id));
return { diff, presentation, omitted, presented, shown: withoutOmittedScreens(presented, omitted), surfaces,
graph: buildViewerGraph(presentation.map, presentation.index, omitted) };
}
test("a public report's never-captured routes are not its screens anywhere; a captured screen and a local map keep theirs", () => {
const review = verifyImages(fixture());
// A new route named in exploration.exclude, and a route that was a redirect and is now a captured screen.
review.surfaces.push({ id: "channel", status: "added", excluded: true, base: null, head: entry("channel", "/c/[channel]") });
const nowCaptured = review.surfaces.find(surface => surface.id === "games-pro");
nowCaptured.status = "modified";
nowCaptured.base = entry("games-pro", "/games", "pro", { kind: "redirect", redirectTo: "/games" });
delete nowCaptured.baseImage; delete nowCaptured.baseOutcome;
const { presentation, presented, omitted, shown, graph } = viewerOmission(review);
assert.equal(presented.screens.get("channel").status, "added", "the comparison alone would count it as a change");
assert.deepEqual([...omitted].sort(), ["channel", "home"], "the excluded route and the redirect; the route captured now stays");
assert.deepEqual(reportScreens(presentation.map.screens, omitted).map(screen => screen.id).sort(),
graph.screens.map(screen => screen.id).sort(), "Screens lists what the Map draws");
assert.deepEqual(buildSearchItems({ screens: reportScreens(presentation.map.screens, omitted) }).filter(item => omitted.has(item.screenId)), []);
assert.deepEqual([...shown.screens.keys()].filter(id => omitted.has(id)), []);
assert.equal(shown.counts.added, presented.counts.added - 1);
assert.equal(shown.counts["not-compared"], presented.counts["not-compared"] - 1);
assert.equal(Object.values(shown.counts).reduce((sum, count) => sum + count, 0), shown.screens.size);
assert.ok(shown.index.screens.has("channel"), "a link to it still opens it");
assert.equal(shown.index.screenNotes.get("channel"), "Excluded by exploration.exclude; never captured");
// A captured route whose excluded variant joins it on one card stays on the Map and in Screens.
const variants = navigationReview();
const pro = variants.surfaces.find(surface => surface.id === "games-pro");
pro.excluded = true;
for (const side of ["base", "head"]) { delete pro[`${side}Image`]; delete pro[`${side}Outcome`]; }
const { current } = workspaceSides(publicReviewToWorkspace(variants));
const family = presentScreensByPath(current.map);
const familyOmitted = omittedScreenIds(current.map, { presentation: family });
const games = family.map.screens.find(screen => screen.route === "/games");
assert.equal(games.variantIds.length, 2);
assert.ok(reportScreens(family.map.screens, familyOmitted).includes(games));
assert.ok(buildViewerGraph(family.map, family.index, familyOmitted).screens.includes(games));
// A local map with the same gaps lists every screen.
const diff = diffFor(review);
const local = { ...diff.map, run: { ...diff.map.run, id: "local-run" } };
assert.equal(omittedScreenIds(local, { diff, presentation: presentScreensByPath(local) }).size, 0);
});
test("an open capture gap keeps a screen that also has an accepted one, from the baseline or from a sibling", () => {
// `/scan/camera` was a redirect and is now a screen whose capture failed: the comparison retargets the baseline's
// accepted redirect gap onto it, beside the head's open failure.
const redirected = verifyImages(fixture());
const camera = redirected.surfaces.find(surface => surface.id === "camera-alias");
camera.status = "modified";
camera.base = entry("camera-alias", "/scan/camera?action=mood", "mood", { kind: "redirect", redirectTo: "/games" });
delete camera.baseImage; delete camera.baseOutcome; delete camera.headImage;
camera.headOutcome = { status: "failed", attempts: 2, landing: "unverified", reason: "timeout" };
const baseline = viewerOmission(redirected);
assert.deepEqual(baseline.diff.map.gaps.filter(gap => gap.screenId === "camera-alias").map(gap => gap.status).sort(), ["accepted", "open"]);
assert.equal(baseline.omitted.has("camera-alias"), false);
assert.equal(baseline.shown.screens.get("camera-alias").status, "unavailable");
assert.equal(baseline.shown.counts.unavailable, 1, "the failed capture is still counted");
assert.ok(baseline.graph.screens.some(screen => screen.id === "camera-alias"));
assert.equal(neverCapturedSurfaceIds(redirected).has("camera-alias"), false);
// `/games` free's capture failed and `/games` pro is excluded: both gaps land on the one `/games` card.
const sibling = verifyImages(fixture());
const pro = sibling.surfaces.find(surface => surface.id === "games-pro");
pro.excluded = true;
for (const side of ["base", "head"]) { delete pro[`${side}Image`]; delete pro[`${side}Outcome`]; }
const free = sibling.surfaces.find(surface => surface.id === "games-free");
delete free.headImage;
free.headOutcome = { status: "failed", attempts: 2, landing: "unverified", reason: "timeout" };
const merged = viewerOmission(sibling);
assert.equal(merged.omitted.has("games-free"), false);
assert.equal(merged.shown.screens.get("games-free").status, "unavailable");
assert.equal(merged.shown.counts.unavailable, 1);
assert.ok(merged.surfaces.has("games-pro"), "the excluded variant itself is still never captured");
assert.equal(merged.surfaces.has("games-free"), false);
});
test("a removed screen keeps its card when the route that replaces it on the same path is a redirect or excluded", () => {
for (const replacement of [
{ kind: "redirect", entry: entry("sweet-bee-new", "/games/sweet-bee", "default", { kind: "redirect", redirectTo: "/games" }) },
{ kind: "excluded", entry: entry("sweet-bee-new", "/games/sweet-bee"), excluded: true },
]) {
const review = verifyImages(fixture());
review.surfaces.push({ id: "sweet-bee-new", status: "added", base: null, head: replacement.entry,
...(replacement.excluded ? { excluded: true } : {}) });
const { omitted, shown, graph, surfaces, presentation } = viewerOmission(review);
const card = presentation.representativeIdByScreenId.get("sweet-bee-new");
assert.equal(omitted.has(card), false, `${replacement.kind}: the removed screen's capture keeps the card`);
assert.ok(shown.screens.get(card)?.beforeScreenshot, `${replacement.kind}: Compare and Changes keep the removed screenshot`);
assert.ok(graph.screens.some(screen => screen.id === card));
assert.ok(surfaces.has("sweet-bee-new"), `${replacement.kind}: the replacement on its own is never captured`);
assert.equal(surfaces.has("sweet-bee"), false);
assert.equal(reviewChanges(review).get("sweet-bee"), "removed", "the comment lists the removal the Viewer shows");
}
});
test("a captured screen that becomes a redirect keeps its card and its screenshot from before", () => {
const review = verifyImages(fixture());
const camera = review.surfaces.find(surface => surface.id === "camera-alias");
camera.status = "modified";
camera.head = entry("camera-alias", "/scan/camera?action=mood", "mood", { kind: "redirect", redirectTo: "/games" });
delete camera.headImage; delete camera.headOutcome;
const { omitted, shown, graph, surfaces } = viewerOmission(review);
assert.equal(omitted.has("camera-alias"), false);
assert.ok(shown.screens.get("camera-alias").beforeScreenshot);
assert.ok(graph.screens.some(screen => screen.id === "camera-alias"));
assert.equal(surfaces.has("camera-alias"), false);
assert.equal(neverCapturedSurfaceIds(review).has("camera-alias"), false);
});
test("the Viewer leaves out exactly the surfaces the PR comment skips", () => {
const review = verifyImages(fixture());
review.surfaces.push(
{ id: "channel", status: "added", excluded: true, base: null, head: entry("channel", "/c/[channel]") },
{ id: "old-start", status: "removed", base: entry("old-start", "/start", "default", { kind: "redirect", redirectTo: "/games" }), head: null },
{ id: "sweet-bee-new", status: "added", base: null, head: entry("sweet-bee-new", "/games/sweet-bee", "default", { kind: "redirect", redirectTo: "/games" }) },
);
const camera = review.surfaces.find(surface => surface.id === "camera-alias");
camera.head = entry("camera-alias", "/scan/camera?action=mood", "mood", { kind: "redirect", redirectTo: "/games" });
camera.status = "modified";
delete camera.headImage; delete camera.headOutcome;
const skipped = neverCapturedSurfaceIds(review);
assert.deepEqual([...skipped].sort(), ["channel", "home", "old-start", "sweet-bee-new"]);
assert.deepEqual([...viewerOmission(review).surfaces].sort(), [...skipped].sort());
const listed = reviewChanges(review);
for (const id of skipped) assert.equal(listed.has(id), false, `${id} is not a listed change`);
assert.equal(listed.get("care-guide"), "added");
assert.equal(listed.get("sweet-bee"), "removed");
const changes = verifyImages(fixture("changes"));
assert.deepEqual([...viewerOmission(changes).surfaces].sort(), [...neverCapturedSurfaceIds(changes)].sort());
const navigated = navigationReview();
assert.deepEqual([...viewerOmission(navigated).surfaces].sort(), [...neverCapturedSurfaceIds(navigated)].sort());
assert.ok(neverCapturedSurfaceIds(navigated).size > 0);
});
+4
View File
@@ -113,6 +113,10 @@ test("the palette's commands follow the canvas: Compare steps changes with the a
assert.ok(!ids(compare).includes("go:compare"));
assert.ok(ids(compare).includes("go:map"));
// Full screen, where the browser has it, prints F; without it there is no command.
assert.equal(commandItems({ ...base, canvas: "map", fullscreen: false }, actions).find((item) => item.id === "command:view:fullscreen").shortcut, "F");
assert.ok(!ids(map).includes("view:fullscreen"));
// A phone has no keyboard shortcuts to list.
assert.ok(ids(map).includes("go:shortcuts"));
assert.ok(!ids(commandItems({ ...base, canvas: "map", phone: true }, actions)).includes("go:shortcuts"));
+8
View File
@@ -70,3 +70,11 @@ test("⌥1–⌥8 open a target by its place, with ⌥ alone; D and ` are plain
assert.ok(matchesShortcut(key("KeyD"), SHORTCUTS.target.menu));
assert.ok(matchesShortcut(key("Backquote"), SHORTCUTS.target.last));
});
test("F is full screen, a plain key: ⌘F stays the browser's find", () => {
assert.equal(formatShortcut(SHORTCUTS.view.fullscreen, true), "F");
assert.ok(matchesShortcut(key("KeyF"), SHORTCUTS.view.fullscreen));
assert.ok(!matchesShortcut(key("KeyF", { metaKey: true }), SHORTCUTS.view.fullscreen));
assert.ok(!matchesShortcut(key("KeyF", { ctrlKey: true }), SHORTCUTS.view.fullscreen));
assert.ok(!matchesShortcut(key("KeyF", { shiftKey: true }), SHORTCUTS.view.fullscreen));
});
+38 -18
View File
@@ -7,12 +7,13 @@ import { isEmbeddedArtifactUrl, leaseEmbeddedArtifactUrl, optionalStorage, viewe
import { REPORT_SOURCE } from "./utils/report-source";
import { CanvasToolbar } from "./components/canvas/toolbar";
import { CanvasCameraControls } from "./components/canvas/camera-controls";
import { MoreMenu } from "./components/canvas/more-menu";
import { CanvasVisibleFrameProvider } from "./components/canvas/visible-frame-provider";
import { AppLoading } from "./components/shared/app-loading";
import { ReportLoadingShell } from "./components/shared/report-loading-shell";
import { screenLabel } from "./utils/screen-path";
import { AppPill, PLATFORM_NAMES, runTargets, siblingReportUrl, targetSwitch } from "./components/panels/app-pill";
import { useFullscreen } from "./components/panels/shell-actions";
import { fullscreenSupported, useFullscreen } from "./components/panels/shell-actions";
import { getCanvasZoomState, runCanvasZoomCommand } from "./utils/canvas-zoom";
import { commandItems, suggestedCommands } from "./utils/commands";
import { changedScreens, focusCounts as countFocusStatuses, isCapturedChange, type ChangedScreen } from "./utils/changed-screens";
@@ -72,6 +73,7 @@ import {
isBlackBoxMap,
} from "./utils/graph-model";
import { buildSearchItems, suggestedSearchItems } from "./utils/search";
import { omittedScreenIds, reportScreens, withoutOmittedScreens } from "./utils/omitted-screens";
import {
presentBuildDiff,
presentScreensByPath,
@@ -383,11 +385,8 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
const revisionRef = useRef<{ runId: string; revision: number } | undefined>(undefined);
const pollingRef = useRef(false);
const theme = themePreference === "system" ? preferredSystemTheme : themePreference;
// Auto → Dark → Light → Auto, as the button's tooltip spells out.
const toggleTheme = useCallback(() => {
setThemePreference(current => current === "system" ? "dark" : current === "dark" ? "light" : "system");
}, []);
// The T key flips what is on screen, dark to light and back; only the button returns to Auto.
// The T key flips what is on screen, dark to light and back; only the More menu's theme switch
// (or the palette) returns to Auto.
const flipTheme = useCallback(() => {
setThemePreference(current => (current === "system" ? preferredSystemTheme : current) === "dark" ? "light" : "dark");
}, [preferredSystemTheme]);
@@ -1043,6 +1042,10 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
setHandoffOpen(true);
} else if (matchesShortcut(event, SHORTCUTS.appearance.theme)) {
flipTheme();
} else if (matchesShortcut(event, SHORTCUTS.view.fullscreen)) {
// The More menu and the palette offer full screen only where the browser has it.
if (phoneRef.current || !fullscreenSupported()) return;
toggleFullscreen();
} else if (matchesShortcut(event, SHORTCUTS.appearance.app)) {
// Only a report captured in both schemes has another appearance to show.
const { options, current } = appearanceRef.current;
@@ -1064,7 +1067,7 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
return () => {
window.removeEventListener("keydown", onKeyDown);
};
}, [chooseAppearance, clearSelectedScreen, flipTheme, navigate, searchOpen, selectCanvas, toggleRightPanel]);
}, [chooseAppearance, clearSelectedScreen, flipTheme, navigate, searchOpen, selectCanvas, toggleFullscreen, toggleRightPanel]);
// A side-panel row or a deep link is a "go to": the camera fits that screen and the step is
// kept. Screens inventory clicks only select in place; Map clicks also focus the chosen screen. Repeating a selected target refits it without adding history.
@@ -1196,11 +1199,18 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
() => (reviewedMap ? presentScreensByPath(reviewedMap) : undefined),
[reviewedMap],
);
// A route the report never captured is not one of its screens, so the comparison names it nowhere (omitted-screens.ts).
const omittedIds = useMemo(
() => (reviewedMap && screenPresentation
? omittedScreenIds(reviewedMap, { diff: sourceDiff, presentation: screenPresentation })
: new Set<string>()),
[reviewedMap, screenPresentation, sourceDiff],
);
const diff = useMemo(
() => (sourceDiff && screenPresentation
? presentBuildDiff(sourceDiff, screenPresentation)
? withoutOmittedScreens(presentBuildDiff(sourceDiff, screenPresentation), omittedIds)
: undefined),
[screenPresentation, sourceDiff],
[omittedIds, screenPresentation, sourceDiff],
);
// The Screens page says which screens changed in an appearance other than the one shown.
const changedElsewhere = useMemo(() => {
@@ -1220,7 +1230,9 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
comparison: filterComparisonAppearance(wholeComparison, otherScope),
...(wholeReview ? { review: filterReviewAppearance(wholeReview, otherScope) } : {}),
});
const presented = presentBuildDiff(otherDiff, presentScreensByPath(otherDiff.map));
const otherPresentation = presentScreensByPath(otherDiff.map);
const presented = withoutOmittedScreens(presentBuildDiff(otherDiff, otherPresentation),
omittedScreenIds(otherDiff.map, { diff: otherDiff, presentation: otherPresentation }));
for (const [id, entry] of presented.screens) {
if (["modified", "added", "removed"].includes(entry.status)) changed.set(id, [...(changed.get(id) ?? []), option]);
}
@@ -1258,9 +1270,10 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
: !baseline ? "This report has no baseline build to compare against."
: !diff ? "The baseline is still loading."
: "No screen looks different from the baseline.";
// Search finds the report's screens, as Screens lists them; a link to one it never captured still opens it.
const searchIndex = useMemo(
() => map ? buildSearchItems({ screens: map.screens }) : [],
[map],
() => map ? buildSearchItems({ screens: reportScreens(map.screens, omittedIds) }) : [],
[map, omittedIds],
);
const openChangedScreen = useCallback((screenId: string) => {
const current = routeRef.current;
@@ -1574,7 +1587,7 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
theme: themePreference,
appearances: appearances.length > 1 ? appearances.map((option) => ({ id: option, label: appearanceLabel(option), current: option === appearance })) : [],
inspector: phone || comparingScreens ? undefined : { open: !rightCollapsed },
fullscreen: !phone && typeof document.documentElement.requestFullscreen === "function" ? fullscreen : undefined,
fullscreen: !phone && fullscreenSupported() ? fullscreen : undefined,
targets: (() => {
const run = runTargets(map.run);
const noun = run.targets.every((target) => target.id === target.platform) ? "platform" as const : "device" as const;
@@ -1632,6 +1645,7 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
index={index}
diff={diff}
routeFiles={routeFiles}
omittedScreenIds={omittedIds}
changedElsewhere={changedElsewhere}
selectedScreenId={selectedScreenId}
{...(focusRequest ? { focusRequest } : {})}
@@ -1684,6 +1698,7 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
direction="TB"
focus={focusFilter}
projectionFitKey={mapProjectionFitKey}
omittedScreenIds={omittedIds}
{...(diff ? { diff } : {})}
{...(selectedScreenId ? { selectedScreenId } : {})}
{...(focusRequest ? { focusRequest } : {})}
@@ -1692,10 +1707,8 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
/>
)}
</div>
{phone ? null : (
<CanvasCameraControls inspectorCollapsed={comparing ? false : rightCollapsed} theme={theme} themePreference={themePreference} onToggleTheme={toggleTheme}
camera={route.canvas === "map"} />
)}
{/* Top right holds the camera only, so only the Map has anything there. */}
{phone || route.canvas !== "map" ? null : <CanvasCameraControls />}
{phone ? (
<PhoneTabBar
canvas={route.canvas}
@@ -1706,7 +1719,13 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
canvas={route.canvas}
searchOpen={searchOpen}
{...(handoffAction ? { actions: handoffAction } : {})}
onOpenShortcuts={() => setShortcutsOpen(true)}
more={<MoreMenu
themePreference={themePreference}
onChangeTheme={setThemePreference}
{...(fullscreenSupported() ? { fullscreen: { active: fullscreen, onToggle: toggleFullscreen } } : {})}
{...(comparingScreens ? {} : { inspector: { open: !rightCollapsed, onToggle: toggleRightPanel } })}
onOpenShortcuts={() => setShortcutsOpen(true)}
/>}
onSelectCanvas={selectCanvas}
onOpenSearch={() => setSearchOpen(true)}
/>}
@@ -1714,6 +1733,7 @@ const ViewerApp = memo(function ViewerApp({ reportKey }: { reportKey: number })
{shortcutsOpen ? (
<ShortcutsDialog
context={{ canvas: route.canvas, review: reviewingInSidebar, hasChanges: compareOrder.length > 0, handoff: Boolean(handoffInput), appearances: appearances.length > 1,
fullscreen: !phone && fullscreenSupported(),
...(switchTargets ? { targets: switchTargets } : {}) }}
onClose={() => setShortcutsOpen(false)}
/>
@@ -6,20 +6,9 @@ import { formatShortcut, SHORTCUTS } from "../../utils/shortcuts";
import { KeyHint } from "../shared/key-hint";
import { Menu, type MenuItem } from "../shared/menu";
import { Tooltip } from "../shared/tooltip";
import { FullscreenToggleButton, ThemeToggleButton, type ShellActionsProps, type ShellTheme } from "../panels/shell-actions";
import { useCanvasVisibleFrame } from "./visible-frame-provider";
import { setFollowSelection, useFollowSelection } from "../../utils/follow-selection";
type CanvasCameraControlsProps = {
/** Makes room for the collapsed inspector controls at the window edge. */
inspectorCollapsed: boolean;
theme: ShellTheme;
themePreference: ShellActionsProps["themePreference"];
onToggleTheme: () => void;
/** Fit, center and zoom act on a canvas; a page (Screens) or Compare shows only the page actions. */
camera?: boolean;
};
const CAMERA_CONTROLS_MINIMUM_FRAME_WIDTH = 240;
function ZoomControl() {
@@ -114,11 +103,11 @@ function RecenterControl() {
}
/**
* Camera actions belong to the canvas, not to either inspector panel. The page-level theme and
* full screen actions share the toolbar, so it stays in one place whether the inspector is open
* or not.
* Camera actions belong to the canvas, not to either inspector panel: fit, center and the zoom
* level, top right on the Map. Screens and Compare have no camera, so nothing renders there; the
* page-wide theme and full screen live in the bottom bar's "More" menu.
*/
export function CanvasCameraControls({ inspectorCollapsed, theme, themePreference, onToggleTheme, camera = true }: CanvasCameraControlsProps) {
export function CanvasCameraControls() {
const { visibleFrame } = useCanvasVisibleFrame();
if (visibleFrame && visibleFrame.width < CAMERA_CONTROLS_MINIMUM_FRAME_WIDTH) return null;
const style = visibleFrame ? ({
@@ -126,24 +115,12 @@ export function CanvasCameraControls({ inspectorCollapsed, theme, themePreferenc
} as CSSProperties) : undefined;
return (
<div
className={`canvas-camera-controls${inspectorCollapsed ? " inspector-collapsed" : ""}`}
style={style}
role="group"
aria-label="Canvas camera controls">
<div className="canvas-camera-controls" style={style} role="group" aria-label="Canvas camera controls">
<div className="canvas-camera-controls-inner">
{camera ? (
<>
<FitControl />
<span className="camera-control-divider" aria-hidden="true" />
<RecenterControl />
<span className="camera-control-divider" aria-hidden="true" />
<ZoomControl />
<span className="camera-control-divider" aria-hidden="true" />
</>
) : null}
<ThemeToggleButton theme={theme} themePreference={themePreference} onToggleTheme={onToggleTheme} className="camera-action-button" />
<FullscreenToggleButton className="camera-action-button" />
<FitControl />
<RecenterControl />
<span className="camera-control-divider" aria-hidden="true" />
<ZoomControl />
</div>
</div>
);
+180
View File
@@ -0,0 +1,180 @@
import { useCallback, useId, useRef, useState, type KeyboardEvent, type ReactNode } from "react";
import { Check, Ellipsis, Keyboard, Maximize, Minimize, Monitor, Moon, PanelRight, Sun } from "lucide-react";
import { Menu } from "../shared/menu";
import { Tooltip } from "../shared/tooltip";
import { formatShortcut, SHORTCUTS } from "../../utils/shortcuts";
import type { ThemePreference } from "../../utils/navigation";
const THEME_OPTIONS: { id: ThemePreference; label: string; title: string; icon: ReactNode }[] = [
{ id: "system", label: "Auto", title: "Auto (system)", icon: <Monitor /> },
{ id: "light", label: "Light", title: "Light", icon: <Sun /> },
{ id: "dark", label: "Dark", title: "Dark", icon: <Moon /> },
];
export type MoreMenuProps = {
themePreference: ThemePreference;
onChangeTheme: (theme: ThemePreference) => void;
/** Full screen's state and toggle; left out where the browser has no full screen. */
fullscreen?: { active: boolean; onToggle: () => void } | undefined;
/** The Inspector's state and toggle; left out where there is no Inspector (Compare). */
inspector?: { open: boolean; onToggle: () => void } | undefined;
onOpenShortcuts: () => void;
};
/**
* The bottom bar's last button: the page-wide settings that have no place on a canvas. Every row
* reads the same way, icon, label, control and key: the Viewer's theme (Auto, Light, Dark; T
* flips light and dark), full screen (F), the Inspector (I) and the keyboard shortcuts (?).
*/
export function MoreMenu(props: MoreMenuProps) {
const [open, setOpen] = useState(false);
const buttonRef = useRef<HTMLButtonElement>(null);
const listRef = useRef<HTMLDivElement>(null);
// The menu opens on the current theme, as a choice menu opens on its current choice.
const currentThemeRef = useRef<HTMLButtonElement>(null);
const themeLabelId = useId();
const close = useCallback(() => setOpen(false), []);
// ↑ and ↓ move between rows (the theme row's stop is its current choice), ← and → between the
// three themes. Tab leaves the menu, as it does a native one. The menu's keys are its own: Esc
// and the arrows are marked used, so a canvas behind it (Compare's screens and areas) leaves them.
// ? opens the shortcuts as the row does, so the dialog hands focus back to More.
const onKeyDown = (event: KeyboardEvent<HTMLDivElement>) => {
const list = listRef.current;
if (!list) return;
if (event.key === "Tab") {
close();
return;
}
if (event.key === "Escape") {
event.preventDefault();
close();
return;
}
if (event.key === "?" && !event.metaKey && !event.ctrlKey && !event.altKey) {
event.preventDefault();
close();
props.onOpenShortcuts();
return;
}
const active = document.activeElement as HTMLElement | null;
if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
event.preventDefault();
const radios = [...list.querySelectorAll<HTMLElement>('[role="menuitemradio"]')];
const at = active ? radios.indexOf(active) : -1;
if (at < 0) return;
radios[(at + (event.key === "ArrowRight" ? 1 : -1) + radios.length) % radios.length]?.focus();
return;
}
if (!["ArrowDown", "ArrowUp", "Home", "End"].includes(event.key)) return;
event.preventDefault();
const rows = [...list.querySelectorAll<HTMLElement>("[data-more-row]")];
if (rows.length === 0) return;
const at = rows.findIndex((row) => active && row.contains(active));
const next = event.key === "Home" ? 0
: event.key === "End" ? rows.length - 1
: (Math.max(at, event.key === "ArrowDown" ? -1 : 0) + (event.key === "ArrowDown" ? 1 : -1) + rows.length) % rows.length;
const row = rows[next];
const stop = row?.matches('[role="menuitem"], [role="menuitemcheckbox"]') ? row
: row?.querySelector<HTMLElement>('[aria-checked="true"]') ?? row?.querySelector<HTMLElement>('[role="menuitemradio"]');
stop?.focus();
};
return (
<>
<Tooltip label="More" placement="top" disabled={open}>
<button
ref={buttonRef}
type="button"
className={`toolbar-button${open ? " active" : ""}`}
aria-label="More"
aria-haspopup="menu"
aria-expanded={open}
onClick={() => setOpen((current) => !current)}>
<Ellipsis />
</button>
</Tooltip>
<Menu open={open} anchorRef={buttonRef} initialFocusRef={currentThemeRef} align="end" className="more-menu" onDismiss={close}>
<div ref={listRef} className="more-menu-list" role="menu" aria-label="More" onKeyDown={onKeyDown}>
<div className="more-menu-row" role="group" aria-labelledby={themeLabelId} data-more-row>
<span className="more-menu-icon" aria-hidden="true"><Moon /></span>
<span className="more-menu-label" id={themeLabelId}>Theme</span>
<span className="more-theme-switch">
{THEME_OPTIONS.map((option) => {
const checked = props.themePreference === option.id;
return (
<button
key={option.id}
ref={checked ? currentThemeRef : undefined}
type="button"
className="more-theme-option"
role="menuitemradio"
aria-checked={checked}
aria-label={option.label}
title={option.title}
tabIndex={-1}
onClick={() => props.onChangeTheme(option.id)}>
{option.icon}
</button>
);
})}
</span>
<kbd className="more-menu-key" aria-hidden="true">{formatShortcut(SHORTCUTS.appearance.theme)}</kbd>
</div>
{props.fullscreen ? (
<button
type="button"
className="more-menu-row more-menu-item"
role="menuitem"
tabIndex={-1}
aria-keyshortcuts={SHORTCUTS.view.fullscreen.key}
data-more-row
onClick={() => {
props.fullscreen?.onToggle();
close();
}}>
<span className="more-menu-icon" aria-hidden="true">{props.fullscreen.active ? <Minimize /> : <Maximize />}</span>
<span className="more-menu-label">{props.fullscreen.active ? "Exit full screen" : "Full screen"}</span>
<kbd className="more-menu-key" aria-hidden="true">{formatShortcut(SHORTCUTS.view.fullscreen)}</kbd>
</button>
) : null}
{props.inspector ? (
<button
type="button"
className="more-menu-row more-menu-item"
role="menuitemcheckbox"
aria-checked={props.inspector.open}
tabIndex={-1}
aria-keyshortcuts={SHORTCUTS.panel.right.key}
data-more-row
onClick={() => {
props.inspector?.onToggle();
close();
}}>
<span className="more-menu-icon" aria-hidden="true"><PanelRight /></span>
<span className="more-menu-label">Inspector</span>
{props.inspector.open ? <span className="more-menu-check" aria-hidden="true"><Check /></span> : null}
<kbd className="more-menu-key" aria-hidden="true">{formatShortcut(SHORTCUTS.panel.right)}</kbd>
</button>
) : null}
<button
type="button"
className="more-menu-row more-menu-item"
role="menuitem"
tabIndex={-1}
aria-haspopup="dialog"
aria-keyshortcuts="?"
data-more-row
onClick={() => {
close();
props.onOpenShortcuts();
}}>
<span className="more-menu-icon" aria-hidden="true"><Keyboard /></span>
<span className="more-menu-label">Keyboard shortcuts</span>
<kbd className="more-menu-key" aria-hidden="true">?</kbd>
</button>
</div>
</Menu>
</>
);
}
+14 -10
View File
@@ -1,7 +1,8 @@
import { GitCompareArrows, Keyboard, LayoutGrid, Map, Search } from "lucide-react";
import { GitCompareArrows, LayoutGrid, Map, Search } from "lucide-react";
import { type CSSProperties, useLayoutEffect, useState } from "react";
import { Tooltip } from "../shared/tooltip";
import { useCanvasVisibleFrame } from "./visible-frame-provider";
import { setToolbarRoom } from "../../utils/inspector-width";
import { CANVAS_NUMBER_KEYS, formatShortcut, SHORTCUTS } from "../../utils/shortcuts";
import { KeyHint } from "../shared/key-hint";
import {
@@ -26,7 +27,8 @@ type CanvasToolbarProps = {
actions?: React.ReactNode;
onSelectCanvas: (canvas: CanvasView) => void;
onOpenSearch: () => void;
onOpenShortcuts: () => void;
/** The bar's last button: the "More" menu with theme, full screen and keyboard shortcuts. */
more: React.ReactNode;
};
/** Room kept between the toolbar and an Inspector wide enough to reach it. */
@@ -47,14 +49,21 @@ export function CanvasToolbar(props: CanvasToolbarProps) {
observer.observe(element);
return () => observer.disconnect();
}, [element]);
// The Inspector stops short of covering the bar: it may widen only as far as leaves the canvas
// room for the bar and a gap either side.
useLayoutEffect(() => {
if (ownWidth > 0) setToolbarRoom(ownWidth + 2 * TOOLBAR_PANEL_GAP);
}, [ownWidth]);
// When responsive panels leave less room than the toolbar itself, hiding it is the only
// collision-free layout. It returns as soon as either panel is collapsed.
// collision-free layout. It returns as soon as either panel is collapsed. The Inspector's width is
// capped to leave the bar its room, so this is a last resort: a desktop window (820px and up)
// always fits the bar beside the narrowest Inspector.
if (visibleFrame && visibleFrame.width < TOOLBAR_MINIMUM_FRAME_WIDTH) return null;
// The toolbar is the canvas' persistent mode switcher. Panel geometry may raise it to avoid
// bottom chrome, but must not pull it away from the window's stable horizontal centre. Only an
// Inspector that would cover it (widened by the reader, or a narrow window's overlay) pushes it
// left, and by just that much, never past the canvas' left edge: with no room left between the
// two, it hides as it does above.
// two, it hides as it does above, which the Inspector's cap keeps from happening.
let shift = 0;
if (visibleFrame && typeof window !== "undefined") {
const centredLeft = window.innerWidth / 2 - ownWidth / 2;
@@ -124,12 +133,7 @@ export function CanvasToolbar(props: CanvasToolbarProps) {
<span className="toolbar-divider" aria-hidden="true" />
<Tooltip label="Keyboard shortcuts" shortcut="?" placement="top">
<button type="button" className="toolbar-button" aria-label="Keyboard shortcuts"
aria-haspopup="dialog" onClick={props.onOpenShortcuts}>
<Keyboard />
</button>
</Tooltip>
{props.more}
</div>
</div>
);
@@ -19,6 +19,8 @@ export type ShortcutContext = {
handoff?: boolean;
/** The report was captured in both light and dark, so the app's appearance can be switched. */
appearances?: boolean;
/** The browser can put the Viewer in full screen. */
fullscreen?: boolean;
/** The run's other targets are one switch away; the pill calls them devices, or platforms in reports from before targets. */
targets?: { noun: "device" | "platform"; count: number };
};
@@ -94,6 +96,7 @@ export function shortcutGroups(context: ShortcutContext): Group[][] {
...(context.canvas === "compare" ? [] : [{ label: "Show or hide the inspector", keys: [SHORTCUTS.panel.right] }]),
{ label: "Viewer theme: dark or light", keys: [SHORTCUTS.appearance.theme] },
...(context.appearances ? [{ label: "The app's appearance: light or dark", keys: [SHORTCUTS.appearance.app] }] : []),
...(context.fullscreen ? [{ label: "Enter or exit full screen", keys: [SHORTCUTS.view.fullscreen] }] : []),
{ label: "Show this list", keys: ["?"] },
],
};
@@ -119,7 +122,7 @@ export function shortcutGroups(context: ShortcutContext): Group[][] {
return [here, [goTo, view]];
}
/** The keyboard reference, opened with "?" or the button at the end of the bottom bar. */
/** The keyboard reference, opened with "?" or from the More menu at the end of the bottom bar. */
export function ShortcutsDialog(props: { context: ShortcutContext; onClose: () => void }) {
const dialogRef = useModalDialog(true, props.onClose);
useEffect(() => {
@@ -2,8 +2,8 @@ import {
useCallback, useRef, useSyncExternalStore, type CSSProperties, type KeyboardEvent, type PointerEvent, type RefObject,
} from "react";
import {
clampInspectorWidth, inspectorWidthBounds, INSPECTOR_WIDTH_MAX, INSPECTOR_WIDTH_MIN, INSPECTOR_WIDTH_STEP,
setInspectorWidth, useInspectorWidth,
clampInspectorWidth, getToolbarRoom, inspectorWidthBounds, INSPECTOR_WIDTH_MAX, INSPECTOR_WIDTH_MIN, INSPECTOR_WIDTH_STEP,
setInspectorWidth, subscribeToToolbarRoom, useInspectorWidth,
type InspectorWidthBounds,
} from "../../utils/inspector-width";
@@ -31,8 +31,22 @@ function subscribeToWindow(onChange: () => void): () => void {
return () => window.removeEventListener("resize", onChange);
}
/** The widest the panel can be now: it follows the window, `--ui-scale` and the bottom bar's width. */
function currentBounds(): InspectorWidthBounds {
return inspectorWidthBounds(window.innerWidth, uiScale(), getToolbarRoom());
}
function subscribeToBounds(onChange: () => void): () => void {
const unsubscribeToolbar = subscribeToToolbarRoom(onChange);
const unsubscribeWindow = subscribeToWindow(onChange);
return () => {
unsubscribeToolbar();
unsubscribeWindow();
};
}
function widestWidth(): number {
return inspectorWidthBounds(window.innerWidth, uiScale()).max;
return currentBounds().max;
}
type Drag = {
@@ -54,7 +68,7 @@ type Drag = {
*/
export function useInspectorResize(panelRef: RefObject<HTMLElement | null>) {
const width = useInspectorWidth();
const widest = useSyncExternalStore(subscribeToWindow, widestWidth, () => INSPECTOR_WIDTH_MAX);
const widest = useSyncExternalStore(subscribeToBounds, widestWidth, () => INSPECTOR_WIDTH_MAX);
const fallback = useSyncExternalStore(subscribeToWindow, defaultWidth, () => 400);
const drag = useRef<Drag | null>(null);
@@ -92,7 +106,7 @@ export function useInspectorResize(panelRef: RefObject<HTMLElement | null>) {
const startWidth = panelWidth(panel);
drag.current = {
pointerId: event.pointerId, startX: event.clientX, startWidth, scale,
bounds: inspectorWidthBounds(window.innerWidth, scale), last: startWidth,
bounds: currentBounds(), last: startWidth,
inline: panel.style.getPropertyValue("--inspector-width"),
};
event.currentTarget.setPointerCapture(event.pointerId);
@@ -126,7 +140,7 @@ export function useInspectorResize(panelRef: RefObject<HTMLElement | null>) {
const onKeyDown = (event: KeyboardEvent<HTMLElement>) => {
const panel = panelRef.current;
if (!panel) return;
const bounds = inspectorWidthBounds(window.innerWidth, uiScale());
const bounds = currentBounds();
const current = panelWidth(panel);
let next: number;
switch (event.key) {
+9 -18
View File
@@ -1,5 +1,5 @@
import { useEffect, useRef } from "react";
import { GitCompareArrows, PanelRight, ScanSearch, X } from "lucide-react";
import { GitCompareArrows, ScanSearch, X } from "lucide-react";
import { Tooltip } from "../shared/tooltip";
import { formatShortcut, SHORTCUTS } from "../../utils/shortcuts";
import { InspectorPanel } from "./inspector";
@@ -59,34 +59,25 @@ export function RightPanel(props: RightPanelProps) {
if (scrollRef.current) scrollRef.current.scrollTop = 0;
}, [screenId]);
// Collapsed, the panel icon brings the Inspector back; open, an X closes it.
// Closed, the Inspector leaves no button behind: a selection, Return or I opens it. Open, an X
// closes it.
if (props.collapsed) return null;
const panelButton = (
<Tooltip
label={props.collapsed ? "Expand inspector" : "Close inspector"}
shortcut={formatShortcut(SHORTCUTS.panel.right)}
placement="bottom-end">
<Tooltip label="Close inspector" shortcut={formatShortcut(SHORTCUTS.panel.right)} placement="bottom-end">
<button
type="button"
className="icon-button"
aria-label={props.collapsed ? "Expand inspector" : "Close inspector"}
aria-expanded={!props.collapsed}
aria-label="Close inspector"
aria-expanded
onClick={props.onToggleCollapsed}>
{props.collapsed ? <PanelRight aria-hidden="true" /> : <X aria-hidden="true" />}
<X aria-hidden="true" />
</button>
</Tooltip>
);
if (props.collapsed) {
return (
<div className="right-float" role="toolbar" aria-label="Canvas actions">
{panelButton}
</div>
);
}
// One header row: the screen's status and path, then the close button. On a phone the close
// button leads the row instead, away from the screen stepper's arrows. Theme and full screen
// live in the canvas camera controls.
// live in the bottom bar's "More" menu.
return (
<aside ref={panelRef} className="right-panel" data-drag-sheet aria-label="Inspector panel" style={phone ? undefined : resize.style}>
{phone ? null : <div className="right-panel-resize" {...resize.handleProps} />}
+13 -60
View File
@@ -1,25 +1,18 @@
import { useEffect, useState } from "react";
import { Maximize, Minimize, Moon, Sun, SunMoon } from "lucide-react";
import { Tooltip } from "../shared/tooltip";
import { formatShortcut, SHORTCUTS } from "../../utils/shortcuts";
import type { ThemePreference } from "../../utils/navigation";
export type ShellTheme = "light" | "dark";
export type ShellActionsProps = {
/** The theme on screen: the preference, or the system's when that is Auto. */
theme: ShellTheme;
themePreference: ThemePreference;
/** Steps Auto → Dark → Light → Auto. */
onToggleTheme: () => void;
/** The host toolbar's button class, so the actions match their neighbours. */
className?: string;
};
import { useCallback, useEffect, useState } from "react";
function fullscreenActive(): boolean {
return typeof document !== "undefined" && document.fullscreenElement !== null;
}
/**
* Whether this browser can put the page in full screen at all: iPhone Safari has no element full
* screen, and a frame that was not allowed it (an embedded Viewer) refuses every request.
*/
export function fullscreenSupported(): boolean {
return typeof document !== "undefined" && typeof document.documentElement.requestFullscreen === "function"
&& document.fullscreenEnabled !== false;
}
/** Tracks the page-level fullscreen state, including exits triggered by the browser itself. */
export function useFullscreen(): [boolean, () => void] {
const [active, setActive] = useState(fullscreenActive);
@@ -30,54 +23,14 @@ export function useFullscreen(): [boolean, () => void] {
return () => document.removeEventListener("fullscreenchange", sync);
}, []);
const toggle = () => {
const toggle = useCallback(() => {
if (document.fullscreenElement) {
void document.exitFullscreen().catch(() => {});
return;
}
if (typeof document.documentElement.requestFullscreen !== "function") return;
if (!fullscreenSupported()) return;
void document.documentElement.requestFullscreen().catch(() => {});
};
}, []);
return [active, toggle];
}
const THEME_LABELS: Record<ThemePreference, string> = {
system: "Theme: Auto (system)",
dark: "Theme: Dark",
light: "Theme: Light",
};
/** The theme button shows the current preference; a press steps Auto → Dark → Light. */
export function ThemeToggleButton(props: ShellActionsProps) {
const Icon = props.themePreference === "system" ? SunMoon : props.themePreference === "dark" ? Moon : Sun;
return (
<Tooltip label={THEME_LABELS[props.themePreference]} shortcut={formatShortcut(SHORTCUTS.appearance.theme)} placement="bottom">
<button
type="button"
className={props.className ?? "icon-button"}
aria-label="Toggle theme"
data-theme-preference={props.themePreference}
onClick={props.onToggleTheme}>
<Icon aria-hidden="true" />
</button>
</Tooltip>
);
}
export function FullscreenToggleButton(props: Pick<ShellActionsProps, "className">) {
const [active, toggle] = useFullscreen();
const label = active ? "Exit full screen" : "Enter full screen";
return (
<Tooltip label={label} placement="bottom">
<button
type="button"
className={props.className ?? "icon-button"}
aria-label={label}
aria-pressed={active}
onClick={toggle}>
{active ? <Minimize aria-hidden="true" /> : <Maximize aria-hidden="true" />}
</button>
</Tooltip>
);
}
-2
View File
@@ -531,8 +531,6 @@
.changes-menu .panel-search-clear { width: 44px; height: 44px; }
/* The minimap repeats what a phone already shows whole, and covers a sixth of it. */
.phone-layout .canvas-minimap-shell { display: none; }
/* With nothing selected there is no Inspector to reopen. */
.phone-layout .right-float { display: none; }
/* The Inspector slides up over the whole screen; a drag down on its header puts it away. */
.phone-layout .right-panel {
/* The sheet is the window's width; the desktop's half-window limit is not for it. */
+18 -1
View File
@@ -237,12 +237,29 @@ export function Menu({ items = [], children, initialFocusRef, open, ariaLabel, c
if (initialFocusRef && event.target instanceof Node
&& !popoverRef.current?.contains(event.target) && !anchorRef?.current?.contains(event.target)) dismissRef.current();
};
// A trigger can also move with no scroll or resize, as the bottom bar does when the Inspector
// opens beside it; an anchored menu checks where its trigger is once a frame while it is open.
let frame = 0;
let anchorAt = "";
const follow = () => {
const rect = anchorRef?.current?.getBoundingClientRect();
const at = rect ? `${rect.left},${rect.top}` : "";
if (at !== anchorAt) {
if (anchorAt) place();
anchorAt = at;
}
frame = requestAnimationFrame(follow);
};
window.addEventListener("pointerdown", onPointerDown);
window.addEventListener("keydown", onKeyDown);
window.addEventListener("resize", place);
if (anchorRef) window.addEventListener("scroll", onScroll, true);
if (anchorRef) {
window.addEventListener("scroll", onScroll, true);
follow();
}
window.addEventListener("focusin", onFocusIn);
return () => {
cancelAnimationFrame(frame);
window.removeEventListener("pointerdown", onPointerDown);
window.removeEventListener("keydown", onKeyDown);
window.removeEventListener("resize", place);
@@ -0,0 +1,22 @@
import type { ExploreMap } from "../../utils/model";
/**
* The Map and Screens with no screen to show. A run that observed none says what stopped it; a public report whose routes
* were all deliberately left uncaptured (omitted-screens.ts) says so, rather than showing an empty page.
*/
export function NoScreens(props: { map: ExploreMap }) {
const recorded = props.map.screens.length > 0;
const blockers = props.map.gaps.filter((gap) => gap.status === "open" && !gap.screenId).map((gap) => gap.message);
return (
<div className="graph-canvas canvas-empty">
<div className="page-empty compact-empty map-empty" role="status">
<h2>{recorded ? "No screens were captured" : "No screens were recorded"}</h2>
{recorded
? <p>Every route in this report is a redirect, is named in exploration.exclude, or is outside what the change reaches.</p>
: blockers.length > 0
? blockers.map((message) => <p key={message}>{message}</p>)
: <p>The run ended before any screen of the app was observed.</p>}
</div>
</div>
);
}
+17 -9
View File
@@ -12,7 +12,9 @@ import { shortcutsLive } from "../../utils/shortcuts";
import { normalizeSearchText } from "../../utils/search";
import { createKeyHold } from "../../utils/key-hold";
import { placeholderScreen } from "../../utils/map-frame";
import { reportScreens } from "../../utils/omitted-screens";
import { ScreenScreenshotCard } from "../canvas/screen-screenshot-card";
import { NoScreens } from "../shared/no-screens";
import { useCanvasVisibleFrame } from "../canvas/visible-frame-provider";
import { PhoneSheet } from "../phone/phone-chrome";
import { PanelSearch } from "../shared/panel-search";
@@ -33,6 +35,8 @@ export type ScreensViewProps = {
/** The other appearances each screen changed in, when the report captured several. */
changedElsewhere?: ReadonlyMap<string, Appearance[]> | undefined;
selectedScreenId?: string | undefined;
/** The routes a public report never captured: not listed, counted or found, as on the Map (omitted-screens.ts). */
omittedScreenIds?: ReadonlySet<string> | undefined;
/** A request (search, the Changes menu) to bring a screen into view; a new key asks again for the same screen. */
focusRequest?: FocusRequest | undefined;
/** The Changes menu's status filter: screens outside it are dimmed, as on the Map. */
@@ -269,19 +273,21 @@ function Legend(props: { others: Appearance[] }) {
* phone, a section per route folder (or per tab, when there are no route files), with the tree behind a Tree button.
*/
export function ScreensView(props: ScreensViewProps) {
// The report's screens, as the Map draws them: a public report's routes it never captured are not among them.
const screens = useMemo(() => reportScreens(props.map.screens, props.omittedScreenIds ?? new Set()), [props.map.screens, props.omittedScreenIds]);
const tree: ScreenTree = useMemo(
() => screenTree(props.map.screens, props.index, props.routeFiles),
[props.index, props.map.screens, props.routeFiles],
() => screenTree(screens, props.index, props.routeFiles),
[props.index, screens, props.routeFiles],
);
const typicalSize = useMemo(
() => typicalScreenshotSize(props.map.screens.map(screen => screenshotSize(primaryScreenshotForScreen(screen, props.index)))),
[props.index, props.map.screens],
() => typicalScreenshotSize(screens.map(screen => screenshotSize(primaryScreenshotForScreen(screen, props.index)))),
[props.index, screens],
);
const changedIds = useMemo(
() => new Set(props.map.screens
() => new Set(screens
.filter(screen => isChanged(props.diff, screen.id) || (props.changedElsewhere?.get(screen.id)?.length ?? 0) > 0)
.map(screen => screen.id)),
[props.changedElsewhere, props.diff, props.map.screens],
[props.changedElsewhere, props.diff, screens],
);
const [filter, setFilter] = useState<Filter>(props.phone && changedIds.size > 0 ? "changed" : "all");
const [treeOpen, setTreeOpen] = useState(false);
@@ -290,9 +296,9 @@ export function ScreensView(props: ScreensViewProps) {
const [query, setQuery] = useState("");
// The phone layout has no field to show or clear a query, so a query typed on desktop does not narrow it.
const findQuery = findOpen && !props.phone ? query : "";
const matches = useMemo(() => findMatches(props.map.screens, props.index, findQuery), [props.index, props.map.screens, findQuery]);
const matches = useMemo(() => findMatches(screens, props.index, findQuery), [props.index, screens, findQuery]);
const inChanged = filter === "changed" && changedIds.size > 0;
const inFilter = inChanged ? changedIds : new Set(props.map.screens.map(screen => screen.id));
const inFilter = inChanged ? changedIds : new Set(screens.map(screen => screen.id));
const shown = matches ? new Set([...inFilter].filter(id => matches.has(id))) : inFilter;
const sections = tree.sections
.map(section => ({ ...section, screenIds: section.screenIds.filter(id => shown.has(id)) }))
@@ -406,7 +412,7 @@ export function ScreensView(props: ScreensViewProps) {
setFilter(value);
}}>
{value === "changed" ? "Changed" : "All"}
<span className="screens-chip-count">{value === "changed" ? changedIds.size : props.map.screens.length}</span>
<span className="screens-chip-count">{value === "changed" ? changedIds.size : screens.length}</span>
</button>
))}
</div>
@@ -563,6 +569,8 @@ export function ScreensView(props: ScreensViewProps) {
? ({ "--screens-right-inset": `calc(100% - ${visibleFrame.x + visibleFrame.width}px)` } as CSSProperties)
: undefined;
if (screens.length === 0) return <NoScreens map={props.map} />;
const cell = (id: string) => {
const screen = props.index.screens.get(id);
return screen ? (
+11 -15
View File
@@ -8,6 +8,7 @@ import {
} from "../canvas/stage";
import type { ProjectionMotionMetadata } from "../canvas/projection-motion";
import { ScreenScreenshotCard } from "../canvas/screen-screenshot-card";
import { NoScreens } from "../shared/no-screens";
import { TransitionEdge, type TransitionGraphEdge } from "../canvas/transition-edge";
import {
buildViewerGraph,
@@ -480,7 +481,11 @@ type BaseCanvasProps = {
onSelectScreen: (id: string, options?: { replace?: boolean }) => void;
onClearSelection?: () => void;
};
export type MapViewProps = BaseCanvasProps & { projectionFitKey?: number };
export type MapViewProps = BaseCanvasProps & {
projectionFitKey?: number;
/** The routes a public report never captured: not drawn (omitted-screens.ts). */
omittedScreenIds?: ReadonlySet<string> | undefined;
};
function ConnectionCanvas(props: MapViewProps) {
const surfaceRef = useRef<HTMLDivElement>(null);
@@ -493,7 +498,10 @@ function ConnectionCanvas(props: MapViewProps) {
});
const previousLayout = useRef<{ nodes: CanvasGraphNode[]; edges: TransitionGraphEdge[] } | undefined>(undefined);
const observedGraph = useMemo(() => buildViewerGraph(props.map, props.index), [props.index, props.map]);
const observedGraph = useMemo(
() => buildViewerGraph(props.map, props.index, props.omittedScreenIds),
[props.index, props.map, props.omittedScreenIds],
);
const projection = useMemo(() => projectFullGraph(observedGraph), [observedGraph]);
const structure = useMemo(
() => projectedStructure(projection, props.index, isBlackBoxMap(props.map)),
@@ -657,19 +665,7 @@ function ConnectionCanvas(props: MapViewProps) {
.sort((left, right) => left.depth - right.depth || left.y - right.y || left.x - right.x || left.index - right.index)
.map(({ id }) => id), [layout.nodes]);
const phone = usePhoneLayout();
if (props.map.screens.length === 0) {
const blockers = props.map.gaps.filter((gap) => gap.status === "open" && !gap.screenId).map((gap) => gap.message);
return (
<div className="graph-canvas canvas-empty">
<div className="page-empty compact-empty map-empty">
<h2>No screens were recorded</h2>
{blockers.length > 0
? blockers.map((message) => <p key={message}>{message}</p>)
: <p>The run ended before any screen of the app was observed.</p>}
</div>
</div>
);
}
if (observedGraph.screens.length === 0) return <NoScreens map={props.map} />;
return (
<div ref={surfaceRef} className="connection-canvas-surface map-surface">
<CanvasStage
+6 -15
View File
@@ -24,7 +24,7 @@ export function reportContractGap(gap: ReviewContractGap): void {
console.warn(`Explore report: ${where} failed the review contract (${gap.message}); ${gap.dropped} omitted.`);
}
import { sourceImpactSentences } from "../../../src/contracts/source-change";
import { navigationCaptureContext } from "../../../src/contracts/navigation-graph";
import { captureContext, captureGap, verifiedCapture } from "../../../src/contracts/surface-capture";
import { projectSourceNavigation } from "../utils/source-navigation";
type Side = "base" | "head";
@@ -89,12 +89,6 @@ function unattributedSummary(surface: Surface, side: Side): string {
return "destination unverified";
}
function verifiedCapture(surface: Surface, side: Side): boolean {
const outcome = side === "base" ? surface.baseOutcome : surface.headOutcome;
return Boolean(surface[side]?.kind === "screen" && imageFor(surface, side)
&& outcome?.status === "captured" && outcome.landing === "verified");
}
function comparisonReview(surface: Surface): Surface["review"] {
if (surface.status === "added" || surface.status === "removed") {
return surface.review?.status === surface.status ? surface.review : undefined;
@@ -217,10 +211,7 @@ function sidePayload(review: PublicReview, side: Side): { map: ExploreMap; cover
const id = routeOf(surface.id);
if (!routes.has(id)) routes.set(id, { ...surface[side]!, id });
}
const selectedRoutes = navigation ? new Set(review.mode === "all" ? [...routes.keys()] : navigationCaptureContext(navigation,
inventory.filter(surface => surface.status !== "unchanged").map(surface => routeOf(surface.id)),
[...routes.values()])) : undefined;
const selected = selectedRoutes ? new Set(inventory.filter(surface => selectedRoutes.has(routeOf(surface.id))).map(surface => surface.id)) : undefined;
const selected = captureContext(review, side);
// Planned structural groups describe the full inventory, including routes outside the
// capture budget. Keep their placeholders available in every canvas.
const declared = inventory;
@@ -356,11 +347,11 @@ function sidePayload(review: PublicReview, side: Side): { map: ExploreMap; cover
screenshotArtifactId: artifact.id,
});
}
if (!verifiedCapture(surface, side)) {
const outcome = side === "base" ? surface.baseOutcome : surface.headOutcome;
// The gap's status is the one the PR comment reads too (surface-capture.ts), so both leave out the same routes.
const gap = captureGap(review, surface, side, selected);
if (gap) {
const outsideCaptureContext = review.mode === "changes" && selected !== undefined && !selected.has(surface.id);
const deliberatelyOmitted = !image && !outcome && (entry.kind === "redirect" || surface.excluded === true || outsideCaptureContext
|| (!navigation && review.mode === "changes" && surface.status === "unchanged"));
const deliberatelyOmitted = gap === "accepted";
map.gaps.push({
id: `capture:${side}:${surface.id}`,
screenId: surface.id,
+66 -67
View File
@@ -133,13 +133,10 @@
--icon-hit-min: 32px;
/* Chevrons, carets and status glyphs that sit inline next to text. */
--icon-glyph-inline: 14px;
/* Floating canvas chrome shares a y=30px center line. The collapsed inspector joins the
camera controls into one compact toolbar. Reserve space for the visible actions only. */
/* Floating canvas chrome shares a y=30px center line. Reserve space for the visible actions only. */
--floating-chrome-top: 14px;
--floating-chrome-height: 42px;
--canvas-chrome-inline-inset: 12px;
--right-float-edge: 12px;
--right-float-width: calc(var(--icon-btn-md) + 6px);
--left-collapsed-pill-width: 420px;
--left-collapsed-pill-height: var(--floating-chrome-height);
--left-collapsed-pill-top: var(--floating-chrome-top);
@@ -304,16 +301,14 @@ code {
}
:root[data-canvas-transition-direction]::view-transition-group(app-pill),
:root[data-canvas-transition-direction]::view-transition-group(canvas-camera-controls),
:root[data-canvas-transition-direction]::view-transition-group(canvas-toolbar),
:root[data-canvas-transition-direction]::view-transition-group(right-floating-controls) {
:root[data-canvas-transition-direction]::view-transition-group(canvas-toolbar) {
z-index: 101;
animation: none;
}
:root[data-canvas-transition-direction]::view-transition-image-pair(canvas-minimap),
:root[data-canvas-transition-direction]::view-transition-image-pair(app-pill),
:root[data-canvas-transition-direction]::view-transition-image-pair(canvas-camera-controls),
:root[data-canvas-transition-direction]::view-transition-image-pair(canvas-toolbar),
:root[data-canvas-transition-direction]::view-transition-image-pair(right-floating-controls) {
:root[data-canvas-transition-direction]::view-transition-image-pair(canvas-toolbar) {
isolation: isolate;
}
:root[data-canvas-transition-direction]::view-transition-old(canvas-view-content),
@@ -325,9 +320,7 @@ code {
:root[data-canvas-transition-direction]::view-transition-old(canvas-toolbar),
:root[data-canvas-transition-direction]::view-transition-old(phone-top-actions),
:root[data-canvas-transition-direction]::view-transition-new(canvas-toolbar),
:root[data-canvas-transition-direction]::view-transition-new(phone-top-actions),
:root[data-canvas-transition-direction]::view-transition-old(right-floating-controls),
:root[data-canvas-transition-direction]::view-transition-new(right-floating-controls) {
:root[data-canvas-transition-direction]::view-transition-new(phone-top-actions) {
mix-blend-mode: normal;
}
:root[data-canvas-transition-direction="forward"]::view-transition-old(canvas-view-content) {
@@ -350,15 +343,13 @@ code {
}
:root[data-canvas-transition-direction]::view-transition-old(app-pill),
:root[data-canvas-transition-direction]::view-transition-old(canvas-camera-controls),
:root[data-canvas-transition-direction]::view-transition-old(canvas-toolbar),
:root[data-canvas-transition-direction]::view-transition-old(right-floating-controls) {
:root[data-canvas-transition-direction]::view-transition-old(canvas-toolbar) {
animation: none;
opacity: 0;
}
:root[data-canvas-transition-direction]::view-transition-new(app-pill),
:root[data-canvas-transition-direction]::view-transition-new(canvas-camera-controls),
:root[data-canvas-transition-direction]::view-transition-new(canvas-toolbar),
:root[data-canvas-transition-direction]::view-transition-new(right-floating-controls) {
:root[data-canvas-transition-direction]::view-transition-new(canvas-toolbar) {
animation: none;
opacity: 1;
}
@@ -1162,33 +1153,6 @@ code {
.inspector-resizing .right-panel-resize::before { opacity: 1; transition-delay: 0ms; }
/* While the edge is dragged nothing else may select or change the cursor. */
.inspector-resizing, .inspector-resizing * { cursor: col-resize !important; user-select: none !important; }
/* When minimised, the inspector actions join the camera controls as one floating toolbar. */
.right-float {
position: fixed;
z-index: 100;
top: var(--chrome-top);
right: var(--right-float-edge);
width: calc(var(--right-float-width) * var(--ui-scale));
height: var(--chrome-height);
display: flex;
align-items: center;
gap: 2px;
padding: calc(3px * var(--ui-scale));
border: 0;
border-radius: 0 calc(8px * var(--ui-scale)) calc(8px * var(--ui-scale)) 0;
background: var(--side-panel-surface);
box-shadow: none;
/* No backdrop blur: the surface is opaque, and a blurred backdrop leaves this toolbar's view
transition snapshot stale, so a button that moves into its place paints late. */
view-transition-name: right-floating-controls;
}
.right-float > * { zoom: var(--ui-scale); }
.right-float .icon-button.active { color: var(--text); background: var(--element); }
.right-float .icon-button[disabled] { color: var(--border); cursor: default; background: transparent; }
.right-float .icon-button:hover {
border-color: transparent;
background: var(--panel-hover);
}
.right-head {
display: flex;
flex: none;
@@ -1247,7 +1211,8 @@ code {
position: absolute;
z-index: 20;
top: var(--chrome-top);
right: calc(var(--canvas-visible-right-inset, 0px) + 8px);
/* Mirrors the pill: the same inset from the canvas' right edge as the pill's from its left. */
right: calc(var(--canvas-visible-right-inset, 0px) + var(--canvas-chrome-inline-inset));
display: inline-flex;
height: var(--chrome-height);
align-items: center;
@@ -1258,30 +1223,9 @@ code {
color: var(--text);
background: var(--side-panel-surface);
box-shadow: var(--floating-chrome-shadow);
/* No backdrop blur, as on .right-float: with it, entering Compare painted full screen late. */
/* No backdrop blur: with it, the view transition's snapshot of these controls painted late. */
view-transition-name: canvas-camera-controls;
}
.canvas-camera-controls.inspector-collapsed {
right: calc(
var(--canvas-visible-right-inset, 0px) +
var(--right-float-edge) + var(--right-float-width) * var(--ui-scale) - 1px
);
border: 0;
border-radius: calc(8px * var(--ui-scale)) 0 0 calc(8px * var(--ui-scale));
box-shadow: none;
}
.canvas-camera-controls.inspector-collapsed::before {
position: absolute;
z-index: -1;
top: 0;
right: calc((var(--right-float-width) * var(--ui-scale) - 1px) * -1);
bottom: 0;
left: 0;
border-radius: calc(8px * var(--ui-scale));
box-shadow: var(--floating-chrome-shadow);
content: "";
pointer-events: none;
}
.canvas-camera-controls .camera-action-button,
.canvas-camera-controls .zoom-button {
border: 0;
@@ -1305,7 +1249,6 @@ code {
flex: none;
background: var(--border-subtle);
}
.canvas-camera-controls.inspector-collapsed .camera-control-divider { display: none; }
.canvas-camera-controls .zoom-button:focus-visible {
outline: 2px solid var(--accent);
outline-offset: 1px;
@@ -2101,6 +2044,61 @@ code {
.menu-row-shortcut { flex: none; margin-left: 16px; color: var(--tertiary); font-size: 11px; }
.menu-separator { height: 1px; margin: 4px 6px; background: var(--popover-line); }
/* ── More menu (the bottom bar's "…") ───────────────────────────────────── */
/* The menu is anchored to its button, but clears the bar the button sits in. The popover itself
is the surface, as the Changes menu's is: an anchored popover scrolls, and would clip a shadow
drawn by the list inside it. Only a window too short for the menu scrolls it. */
.menu-popover.more-menu {
overflow-x: hidden !important;
border: 1px solid var(--popover-line);
border-radius: calc(9px * var(--ui-scale));
background: var(--popover);
box-shadow: var(--popover-shadow);
translate: 0 calc(-12px * var(--ui-scale));
}
/* Rows read icon, label, control, key, in the menu's own type and colours. */
.more-menu-list { display: flex; width: 248px; flex-direction: column; padding: 4px; }
.more-menu-row {
display: flex;
width: 100%;
min-height: 34px;
align-items: center;
gap: 8px;
padding: 4px 6px 4px 8px;
border-radius: 5px;
color: var(--text);
background: transparent;
font-size: 12px;
text-align: left;
}
.more-menu-item:hover,
.more-menu-item:focus-visible { background: var(--popover-hover); outline: none; }
.more-menu-icon { display: flex; width: 16px; flex: none; align-items: center; justify-content: center; color: var(--secondary); }
.more-menu-icon > svg { width: 15px; height: 15px; }
.more-menu-label { min-width: 0; flex: 1; white-space: nowrap; }
.more-menu-check { display: flex; flex: none; color: var(--secondary); }
.more-menu-check > svg { width: 14px; height: 14px; }
/* The key column lines up down the menu, whatever the row holds before it. */
.more-menu-key { min-width: 22px; flex: none; text-align: center; }
/* A compact three-way switch: Auto, Light, Dark, on the segmented control's track and thumb. */
.more-theme-switch { display: flex; flex: none; gap: 2px; padding: 2px; border-radius: 7px; background: var(--segment-track); }
.more-theme-option {
display: flex;
width: 26px;
height: 22px;
align-items: center;
justify-content: center;
border-radius: 5px;
color: var(--tertiary);
background: transparent;
transition: color 120ms ease, background 120ms ease;
}
.more-theme-option > svg { width: 14px; height: 14px; }
.more-theme-option:hover { color: var(--text); }
.more-theme-option[aria-checked="true"] { color: var(--text); background: var(--segment-thumb); box-shadow: 0 1px 2px rgb(0 0 0 / 0.12); }
.more-theme-option:focus-visible { outline: 2px solid var(--accent); outline-offset: 0; }
/* ── Feedback dialog ────────────────────────────────────────────────────── */
.dialog-backdrop {
@@ -2247,7 +2245,8 @@ code {
.search-command-result-copy code { color: inherit; font-size: inherit; }
.search-command-section + .search-command-section { margin-top: 4px; }
.search-command-section > .search-command-section-label { padding: 8px 8px 4px; }
.search-command-result-key {
.search-command-result-key,
.more-menu-key {
padding: 2px 6px;
border: 1px solid var(--border);
border-radius: 5px;
+2 -1
View File
@@ -102,7 +102,8 @@ export function commandItems(context: CommandContext, actions: CommandActions):
{ keywords: ["app", "appearance", "scheme", "captured"], shortcut: !appearance.current && context.appearances.length === 2 ? key(SHORTCUTS.appearance.app) : undefined });
}
if (context.fullscreen !== undefined) {
add("view:fullscreen", "View", context.fullscreen ? "Exit full screen" : "Enter full screen", actions.toggleFullscreen, { keywords: ["fullscreen", "window", "focus"] });
add("view:fullscreen", "View", context.fullscreen ? "Exit full screen" : "Enter full screen", actions.toggleFullscreen,
{ keywords: ["fullscreen", "window", "focus"], shortcut: key(SHORTCUTS.view.fullscreen) });
}
for (const target of context.targets) {
+9 -8
View File
@@ -123,15 +123,16 @@ export function buildObservedGraph(map: ExploreMap, index: MapIndex): ObservedGr
};
}
/** The Viewer can overlay declarations; the observed graph and event indexes stay intact. */
export function buildViewerGraph(map: ExploreMap, index: MapIndex): ObservedGraph {
const NONE: ReadonlySet<string> = new Set();
/**
* The Viewer can overlay declarations; the observed graph and event indexes stay intact. A public report preserves its
* complete source inventory, but the routes it never captured are not its screens: `omitted` names them, the one set
* every view of the report takes (omitted-screens.ts). The launch is never among them: it is where the app starts,
* drawn above the start screens with a synthetic edge into each of them.
*/
export function buildViewerGraph(map: ExploreMap, index: MapIndex, omitted: ReadonlySet<string> = NONE): ObservedGraph {
const observed = buildObservedGraph(map, index);
// A public report preserves its complete source inventory, but an accepted capture gap
// marks a redirect or a route outside changes-mode selection. Neither is a screen image. The app
// launch is not a route, so its accepted "no splash observed" gap keeps it on the map: it is where
// the app starts, drawn above the start screens with a synthetic edge into each of them.
const omitted = new Set<string>();
if (map.run.id.startsWith("public:")) for (const gap of map.gaps) if (gap.status === "accepted" && gap.screenId && !isLaunchScreen({ id: gap.screenId })) omitted.add(gap.screenId);
const screens = observed.screens.filter(screen => !omitted.has(screen.id));
const visibleIds = new Set(screens.map(screen => screen.id));
const launchEdges = launchGroups(screens);
+28 -4
View File
@@ -43,15 +43,39 @@ export function useInspectorWidth(): number | undefined {
);
}
/** The room the bottom bar needs beside the Inspector, in window pixels: its measured width and a gap either side. */
let toolbarRoom = 0;
const toolbarListeners = new Set<() => void>();
/** The bottom bar reports the room it needs whenever its measured width changes (with `--ui-scale` too). */
export function setToolbarRoom(room: number) {
if (room === toolbarRoom) return;
toolbarRoom = room;
for (const listener of toolbarListeners) listener();
}
export function getToolbarRoom(): number {
return toolbarRoom;
}
export function subscribeToToolbarRoom(onChange: () => void): () => void {
toolbarListeners.add(onChange);
return () => toolbarListeners.delete(onChange);
}
export type InspectorWidthBounds = { min: number; max: number };
/**
* The widths the panel may take in a window `windowWidth` wide: at most half of it, so the canvas
* keeps the other half, in the panel's own (unscaled) pixels when the chrome is zoomed by `scale`.
* keeps the other half, and never so wide that the canvas beside it loses the `toolbarRoom` the
* bottom bar needs (window pixels), in the panel's own (unscaled) pixels when the chrome is zoomed
* by `scale`. Neither cap goes below the minimum.
*/
export function inspectorWidthBounds(windowWidth: number, scale = 1): InspectorWidthBounds {
const half = Math.floor(windowWidth / 2 / (scale > 0 ? scale : 1));
return { min: INSPECTOR_WIDTH_MIN, max: Math.max(INSPECTOR_WIDTH_MIN, Math.min(INSPECTOR_WIDTH_MAX, half)) };
export function inspectorWidthBounds(windowWidth: number, scale = 1, room = 0): InspectorWidthBounds {
const zoom = scale > 0 ? scale : 1;
const half = Math.floor(windowWidth / 2 / zoom);
const besideBar = Math.floor((windowWidth - room) / zoom);
return { min: INSPECTOR_WIDTH_MIN, max: Math.max(INSPECTOR_WIDTH_MIN, Math.min(INSPECTOR_WIDTH_MAX, half, besideBar)) };
}
export function clampInspectorWidth(width: number, bounds: InspectorWidthBounds): number {
+73
View File
@@ -0,0 +1,73 @@
import type { BuildDiff, DiffStatus, ScreenDiff } from "./build-diff";
import { isLaunchScreen, type ExploreMap, type Screen } from "./model";
import type { ScreenPresentation } from "./screen-presentation";
const NONE: ReadonlySet<string> = new Set();
/**
* The screens of a public report's map, before path grouping, that the run never captured on purpose: a redirect
* declaration, a route named in `exploration.exclude`, or one outside the capture context in changes mode. Each has an
* accepted capture gap, no open one, and no screenshot of its own on either side. A screenshot a redirect borrows from
* the route it declares is not its own: build-diff names a side's own capture by its observation id. An open gap, such
* as a failed capture, keeps the screen: its failure is part of the report. The app launch is not a route, and a local
* map leaves nothing out.
*
* This is the map's view of `neverCapturedSurfaceIds` (src/contracts/surface-capture.ts), which the PR comment uses.
*/
export function omittedSourceScreenIds(
source: Pick<ExploreMap, "run" | "gaps" | "screens">,
diff?: Pick<BuildDiff, "screens">,
): ReadonlySet<string> {
if (!source.run.id.startsWith("public:")) return NONE;
const accepted = new Set<string>();
const open = new Set<string>();
for (const gap of source.gaps) {
if (gap.screenId && gap.status === "accepted") accepted.add(gap.screenId);
if (gap.screenId && gap.status === "open") open.add(gap.screenId);
}
const omitted = new Set<string>();
for (const screen of source.screens) {
if (!accepted.has(screen.id) || open.has(screen.id) || isLaunchScreen(screen) || screen.observationIds.length > 0) continue;
const compared = diff?.screens.get(screen.id);
if (compared?.baselineObservationId || compared?.currentObservationId) continue;
omitted.add(screen.id);
}
return omitted;
}
/**
* The screens none of the report's views list: the Map, Screens, search, Compare, the Changes list and their counts all
* take this one set. With a path presentation, a card leaves only when every screen it stands for does, a removed one
* included, so a card whose current route is a redirect still shows the screenshot of the screen it replaced. The map's
* index keeps them all: a link to one opens it in the Inspector, which says why it has no screenshot.
*/
export function omittedScreenIds(
source: Pick<ExploreMap, "run" | "gaps" | "screens">,
options: { diff?: Pick<BuildDiff, "screens"> | undefined; presentation?: Pick<ScreenPresentation, "families"> | undefined } = {},
): ReadonlySet<string> {
const members = omittedSourceScreenIds(source, options.diff);
if (!options.presentation || members.size === 0) return members;
return new Set(options.presentation.families
.filter((family) => family.members.every((member) => members.has(member.id)))
.map((family) => family.representative.id));
}
/** The report's screens: the map's screens but the omitted ones. */
export function reportScreens<T extends Pick<Screen, "id">>(screens: readonly T[], omitted: ReadonlySet<string>): readonly T[] {
return omitted.size ? screens.filter((screen) => !omitted.has(screen.id)) : screens;
}
/**
* The comparison without the omitted screens, so no count, Changes row, Compare step or Changed filter names a route
* that was never captured. Its map and index keep them, for a link to one.
*/
export function withoutOmittedScreens(diff: BuildDiff, omitted: ReadonlySet<string>): BuildDiff {
if (![...diff.screens.keys()].some((id) => omitted.has(id))) return diff;
const screens = new Map<string, ScreenDiff>();
const counts: Record<DiffStatus, number> = { ...diff.counts };
for (const [id, screen] of diff.screens) {
if (omitted.has(id)) counts[screen.status] -= 1;
else screens.set(id, screen);
}
return { ...diff, screens, counts };
}
+4
View File
@@ -77,6 +77,10 @@ export const SHORTCUTS = {
theme: plain("KeyT", "T"),
app: shift("KeyT", "T"),
},
/** F puts the whole Viewer in or out of full screen, where the browser allows it. */
view: {
fullscreen: plain("KeyF", "F"),
},
/** Canvas edits follow the platform-standard history keys. */
edit: {
undo: mod("KeyZ", "Z"),