Compare commits

...
Author SHA1 Message Date
Brent Vatne 906ee5e7a1 More menu: keep its keys from the canvas behind it, follow the bar, add an Inspector row, offer full screen only where it is allowed
←/→ on any row and Esc are the menu's own, so Compare neither steps its screen nor clears its
area; ? from the menu opens the shortcuts as the row does, so focus returns to More. An anchored
menu follows its trigger when it moves without a scroll or resize. Full screen also needs
document.fullscreenEnabled. A window too short for the menu scrolls it.
2026-10-19 08:53:04 -07:00
Brent Vatne fa970beac3 Inspector: widen only as far as leaves the bottom bar room beside it, so the bar and its More never hide
The cap, window width less the bar's measured width and a 12px gap either side (never below
320px), joins #34's min(800px, half the window) for drags, keys, the saved width and resizes;
the separator's aria-valuemax follows it.
2026-10-19 08:53:04 -07:00
Brent Vatne f4e58bd849 Merge remote-tracking branch 'origin/main' into @brent/bottom-bar-menu
# Conflicts:
#	viewer/src/components/canvas/toolbar.tsx
#	viewer/src/styles.css
2026-10-18 22:43:18 -07:00
Brent Vatne 650c5fae2f Viewer chrome: theme, full screen and keyboard shortcuts move into a "…" menu in the bottom bar; the top right keeps only the Map's camera
The bottom bar's keyboard button becomes More, a menu of uniform rows (icon, label, control, key): Theme with an Auto / Light / Dark switch (T), Full screen (F, a new key) where the browser has it, and Keyboard shortcuts (?). The top right loses the theme and full screen buttons on every canvas and the Inspector's panel toggle; the Inspector opens from a selection, Return or I.
2026-10-18 22:39:59 -07:00
devin-ai-integration[bot]andbrent b281c734f4 Viewer: make the Inspector resizable from its left edge (#34)
Co-authored-by: brent <[email protected]>
Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
2026-10-18 22:39:36 -07:00
Brent Vatne c99c26f9bb Release 0.20.0-next.0; prereleases publish under the next tag (#36) 2026-10-18 22:09:03 -07:00
Brent Vatne 9150a24cd9 Map: ring the selected screen instead of fading the rest; Return opens the screen the arrows reached (#35) 2026-10-18 22:05:21 -07:00
30 changed files with 1723 additions and 573 deletions

No files matched your search

+7 -1
View File
@@ -61,7 +61,13 @@ jobs:
env:
# npm cannot generate provenance for a private repository.
NPM_CONFIG_PROVENANCE: "false"
run: npm publish --access public
VERSION: ${{ steps.version.outputs.version }}
shell: bash
# A prerelease (0.20.0-next.0) goes to the next tag, so latest keeps the last release.
run: |
set -euo pipefail
if [[ "$VERSION" == *-* ]]; then tag=next; else tag=latest; fi
npm publish --access public --tag "$tag"
- name: Tag the release
if: steps.version.outputs.publish == 'true'
env:
+1 -1
View File
@@ -580,7 +580,7 @@ npm test
- `npm test` rebuilds the CLI and the Viewer first, because the node tests run the compiled `dist/`. After one `npm run build`, `npm run test:node` skips the rebuild.
- The agent runtimes and `eas-cli` are optional dependencies that only capture needs. Do not install with `--omit=optional`, which also drops esbuild's platform package.
- To release, bump `version` in `package.json` and merge to main. The [publish workflow](.github/workflows/publish.yml) publishes any version npm does not have yet.
- To release, bump `version` in `package.json` and merge to main. The [publish workflow](.github/workflows/publish.yml) publishes any version npm does not have yet. A prerelease version such as `0.20.0-next.0` goes to the `next` tag, so `latest` stays on the last release.
```sh
npx playwright install chromium
+2 -2
View File
@@ -1,12 +1,12 @@
{
"name": "@expo/explore",
"version": "0.19.8",
"version": "0.20.0-next.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "@expo/explore",
"version": "0.19.8",
"version": "0.20.0-next.0",
"license": "MIT",
"dependencies": {
"@expo/repack-app": "0.10.1",
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/explore",
"version": "0.19.8",
"version": "0.20.0-next.0",
"description": "Source-driven mobile app maps, deterministic CI capture, and visual reviews",
"license": "MIT",
"type": "module",
@@ -188,12 +188,11 @@ test("Map keeps selected elevated arrows behind screenshots without rendering na
await expect(sourceHitArea.locator("title")).toHaveText("Source navigation\npush · app/home.tsx");
await page.mouse.move(1320, 30);
const dimmedComparisons = [];
for (const presentation of ["muted", "selection"]) {
// Only the Changes filter dims a screen; a selection fades nothing.
for (const presentation of ["muted"]) {
await page.evaluate(mode => {
const profile = document.querySelector('.react-flow__node[data-id="profile"]');
const canvas = document.querySelector(".map-canvas");
profile.classList.toggle("graph-node-muted", mode === "muted");
canvas.classList.toggle("screen-selection-active", mode === "selection");
}, presentation);
const dimmedWithArrows = await profileImage.screenshot({ animations: "disabled" });
await page.locator(".map-surface .react-flow__edges").evaluate(node => { node.style.visibility = "hidden"; });
@@ -216,7 +215,6 @@ test("Map keeps selected elevated arrows behind screenshots without rendering na
}
await page.evaluate(() => {
document.querySelector('.react-flow__node[data-id="profile"]').classList.remove("graph-node-muted");
document.querySelector(".map-canvas").classList.remove("screen-selection-active");
});
await page.getByRole("button", { name: "Open Profile", exact: true }).click();
assert.equal(await page.evaluate(() => window.selectedScreen), "profile");
+8
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);
+266
View File
@@ -0,0 +1,266 @@
import { expect, test, type Page } from "@playwright/test";
const STORAGE_KEY = "expo-explore:inspector-width";
const panel = (page: Page) => page.getByRole("complementary", { name: "Inspector panel" });
const handle = (page: Page) => page.getByRole("separator", { name: "Resize inspector" });
const panelWidth = async (page: Page) => (await panel(page).boundingBox())!.width;
const storedWidth = (page: Page) => page.evaluate((key) => localStorage.getItem(key), STORAGE_KEY);
/** Drags the panel's edge `dx` pixels (negative is left, which widens the panel). */
async function dragEdge(page: Page, dx: number) {
const box = (await handle(page).boundingBox())!;
const x = box.x + box.width / 2;
const y = box.y + box.height / 2;
await page.mouse.move(x, y);
await page.mouse.down();
await page.mouse.move(x + dx / 2, y);
await page.mouse.move(x + dx, y);
await page.mouse.up();
}
test.describe("Inspector resize", () => {
test("dragging the edge resizes the Inspector, and the width is kept for the next visit", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
// The 1280px test window takes the wide default.
expect(await panelWidth(page)).toBe(400);
await expect(handle(page)).toHaveAttribute("aria-valuenow", "400");
await dragEdge(page, -150);
await expect.poll(() => panelWidth(page)).toBe(550);
await expect(handle(page)).toHaveAttribute("aria-valuenow", "550");
expect(await storedWidth(page)).toBe("550");
await page.reload();
await expect(panel(page)).toBeVisible();
await expect.poll(() => panelWidth(page)).toBe(550);
// Dragging back right narrows it, never below the minimum.
await dragEdge(page, 400);
await expect.poll(() => panelWidth(page)).toBe(320);
expect(await storedWidth(page)).toBe("320");
});
test("the width stops at half the window, and a double-click restores the default", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
await dragEdge(page, -600);
await expect.poll(() => panelWidth(page)).toBe(640);
await expect(handle(page)).toHaveAttribute("aria-valuemax", "640");
await expect(handle(page)).toHaveAttribute("aria-valuenow", "640");
// The canvas toolbar moves left, out from under the wide panel, instead of being covered.
const toolbar = page.getByRole("toolbar", { name: "Canvas tools" });
await expect(toolbar).toBeVisible();
await expect.poll(async () => {
const toolbarBox = (await toolbar.boundingBox())!;
const panelBox = (await panel(page).boundingBox())!;
return panelBox.x - (toolbarBox.x + toolbarBox.width);
}).toBeGreaterThanOrEqual(8);
await handle(page).dblclick();
await expect.poll(() => panelWidth(page)).toBe(400);
expect(await storedWidth(page)).toBeNull();
});
test("arrow keys move the edge a step; Home and End take it to its limits", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
await handle(page).focus();
await page.keyboard.press("ArrowLeft");
await expect.poll(() => panelWidth(page)).toBe(416);
await page.keyboard.press("ArrowLeft");
await expect.poll(() => panelWidth(page)).toBe(432);
await page.keyboard.press("ArrowRight");
await expect.poll(() => panelWidth(page)).toBe(416);
await page.keyboard.press("End");
await expect.poll(() => panelWidth(page)).toBe(640);
await page.keyboard.press("Home");
await expect.poll(() => panelWidth(page)).toBe(320);
// The arrows resized the panel; they did not step the selected screen.
expect(new URL(page.url()).searchParams.get("screen")).toBe("area-0-screen-1");
});
test("a saved width wider than half of a smaller window is held to half of it", async ({ page }) => {
await page.addInitScript((key) => localStorage.setItem(key, "760"), STORAGE_KEY);
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
expect(await panelWidth(page)).toBe(640);
await expect(handle(page)).toHaveAttribute("aria-valuenow", "640");
});
test("a drag that ends where it started leaves the default width in place", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
const box = (await handle(page).boundingBox())!;
const x = box.x + box.width / 2;
const y = box.y + box.height / 2;
await page.mouse.move(x, y);
await page.mouse.down();
await page.mouse.move(x - 100, y);
await expect.poll(() => panelWidth(page)).toBe(500);
await page.mouse.move(x, y);
await page.mouse.up();
await expect.poll(() => panelWidth(page)).toBe(400);
expect(await storedWidth(page)).toBeNull();
// Still the default: a narrower window takes the narrow default, not the 400 the drag passed through.
await page.setViewportSize({ width: 1100, height: 820 });
await expect.poll(() => panelWidth(page)).toBe(320);
});
test("a saved width below the minimum is held to it", async ({ page }) => {
await page.addInitScript((key) => localStorage.setItem(key, "40"), STORAGE_KEY);
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
expect(await panelWidth(page)).toBe(320);
await expect(handle(page)).toHaveAttribute("aria-valuenow", "320");
});
test.describe("in a window wider than two maximum panels", () => {
test.use({ viewport: { width: 1700, height: 900 } });
test("a saved width above the maximum is held to it", async ({ page }) => {
await page.addInitScript((key) => localStorage.setItem(key, "5000"), STORAGE_KEY);
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
// Half of this window is 850.
expect(await panelWidth(page)).toBe(800);
await expect(handle(page)).toHaveAttribute("aria-valuenow", "800");
});
});
test("a key that cannot move the edge keeps the saved width", async ({ page }) => {
await page.addInitScript((key) => localStorage.setItem(key, "760"), STORAGE_KEY);
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
expect(await panelWidth(page)).toBe(640);
await handle(page).focus();
await page.keyboard.press("End");
await page.keyboard.press("ArrowLeft");
expect(await storedWidth(page)).toBe("760");
await page.keyboard.press("ArrowRight");
await expect.poll(() => panelWidth(page)).toBe(624);
expect(await storedWidth(page)).toBe("624");
});
test("the separator's values follow the window", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
await handle(page).focus();
await page.keyboard.press("End");
await expect(handle(page)).toHaveAttribute("aria-valuenow", "640");
await page.setViewportSize({ width: 1000, height: 820 });
await expect.poll(() => panelWidth(page)).toBe(500);
await expect(handle(page)).toHaveAttribute("aria-valuemax", "500");
await expect(handle(page)).toHaveAttribute("aria-valuenow", "500");
// Back in the wide window the saved width returns.
await page.setViewportSize({ width: 1280, height: 820 });
await expect.poll(() => panelWidth(page)).toBe(640);
await expect(handle(page)).toHaveAttribute("aria-valuenow", "640");
});
test("closing the Inspector mid-drag ends the drag", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
const box = (await handle(page).boundingBox())!;
const x = box.x + box.width / 2;
const y = box.y + box.height / 2;
await page.mouse.move(x, y);
await page.mouse.down();
await page.mouse.move(x - 100, y);
await expect(page.locator("html")).toHaveClass(/inspector-resizing/);
await page.keyboard.press("i");
await expect(panel(page)).toHaveCount(0);
await page.mouse.up();
await expect(page.locator("html")).not.toHaveClass(/inspector-resizing/);
// The width the drag reached is kept.
await page.keyboard.press("i");
await expect.poll(() => panelWidth(page)).toBe(500);
});
test.describe("in a window too narrow for the toolbar beside a half-window Inspector", () => {
test.use({ viewport: { width: 820, height: 800 } });
/** 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 expect(toolbar.getByRole("button", { name: "More", exact: true })).toBeVisible();
const toolbarBox = (await toolbar.boundingBox())!;
const panelBox = (await panel(page).boundingBox())!;
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);
});
});
test.describe("in a narrow window", () => {
test.use({ viewport: { width: 1180, height: 820 } });
test("the Inspector starts at its narrow default, and a saved width is held to half the window", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
expect(await panelWidth(page)).toBe(320);
await expect(handle(page)).toHaveAttribute("aria-valuenow", "320");
await page.evaluate((key) => localStorage.setItem(key, "760"), STORAGE_KEY);
await page.reload();
await expect(panel(page)).toBeVisible();
expect(await panelWidth(page)).toBe(590);
await expect(handle(page)).toHaveAttribute("aria-valuenow", "590");
});
});
test.describe("on a phone", () => {
test.use({ viewport: { width: 390, height: 844 }, hasTouch: true, isMobile: true });
test("the Inspector sheet has no resize edge", async ({ page }) => {
await page.goto("/map?screen=area-0-screen-1");
await expect(panel(page)).toBeVisible();
await expect(handle(page)).toHaveCount(0);
});
});
});
+605 -283
View File
File diff suppressed because it is too large. Load diff
+35
View File
@@ -0,0 +1,35 @@
import assert from "node:assert/strict";
import test from "node:test";
const { tsImport } = await import("tsx/esm/api");
const { clampInspectorWidth, inspectorWidthBounds, INSPECTOR_WIDTH_MAX, INSPECTOR_WIDTH_MIN } =
await tsImport("../../viewer/src/utils/inspector-width.ts", import.meta.url);
test("the Inspector may take at most half the window, within its fixed range", () => {
assert.deepEqual(inspectorWidthBounds(1440), { min: INSPECTOR_WIDTH_MIN, max: 720 });
assert.deepEqual(inspectorWidthBounds(2560), { min: INSPECTOR_WIDTH_MIN, max: INSPECTOR_WIDTH_MAX });
// A window narrower than two minimum panels still allows the minimum.
assert.deepEqual(inspectorWidthBounds(500), { min: INSPECTOR_WIDTH_MIN, max: INSPECTOR_WIDTH_MIN });
});
test("the bounds are in the panel's own pixels when the chrome is zoomed", () => {
assert.deepEqual(inspectorWidthBounds(1600, 1.25), { min: INSPECTOR_WIDTH_MIN, max: 640 });
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);
assert.equal(clampInspectorWidth(1000, bounds), 720);
assert.equal(clampInspectorWidth(455.6, bounds), 456);
});
+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));
});
+20 -13
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";
@@ -383,11 +384,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 +1041,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 +1066,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.
@@ -1574,7 +1576,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;
@@ -1692,10 +1694,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 +1706,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 +1720,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>
</>
);
}
@@ -31,8 +31,8 @@ export type ScreenScreenshotCardProps = {
loading?: "eager" | "lazy";
leading?: ReactNode;
trailing?: ReactNode;
/** Where the "Open in Inspector" tooltip sits: away from the route heading, which is above the screenshot on the Map. */
tooltipPlacement?: "top" | "bottom";
/** Say "Open in Inspector" in a tooltip over the screenshot (Screens). The Map's cards go without. */
inspectorTooltip?: boolean;
/** Short lines about the screen, inside the card after its screenshot (Screens: how it was reached, where else it changed). */
note?: ReactNode;
onClick: MouseEventHandler<HTMLButtonElement>;
@@ -92,10 +92,10 @@ export function ScreenScreenshotCard(props: ScreenScreenshotCardProps) {
free of block children. */}
<span className="screen-screenshot-slot">
{props.leading}
{/* With a pointer, what a click does is said once, zoom-independent, in the shared tooltip
after its usual delay; the selected screen is already in the Inspector. The button has
no title of its own, so no native tooltip joins it; the heading names the screen. */}
<Tooltip label="Open in Inspector" placement={props.tooltipPlacement ?? "top"} disabled={Boolean(props.selected)}>
{/* On Screens, with a pointer, what a click does is said once in the shared tooltip after
its usual delay; the selected screen is already in the Inspector. The button has no
title of its own, so no native tooltip joins it; the heading names the screen. */}
<Tooltip label="Open in Inspector" placement="top" disabled={props.inspectorTooltip === false || Boolean(props.selected)}>
<button
type="button"
className="screen-screenshot-target"
+44 -12
View File
@@ -1,7 +1,8 @@
import { GitCompareArrows, Keyboard, LayoutGrid, Map, Search } from "lucide-react";
import { type CSSProperties } from "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,23 +27,59 @@ 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. */
const TOOLBAR_PANEL_GAP = 12;
export function CanvasToolbar(props: CanvasToolbarProps) {
const { visibleFrame } = useCanvasVisibleFrame();
// The bar as mounted now: it unmounts while hidden, and its last width is kept for deciding when
// it fits again.
const [element, setElement] = useState<HTMLDivElement | null>(null);
const [ownWidth, setOwnWidth] = useState(0);
useLayoutEffect(() => {
if (!element) return;
const measure = () => setOwnWidth(element.getBoundingClientRect().width);
measure();
if (typeof ResizeObserver === "undefined") return;
const observer = new ResizeObserver(measure);
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.
// 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, which the Inspector's cap keeps from happening.
let shift = 0;
if (visibleFrame && typeof window !== "undefined") {
const centredLeft = window.innerWidth / 2 - ownWidth / 2;
const needed = centredLeft + ownWidth + TOOLBAR_PANEL_GAP - (visibleFrame.x + visibleFrame.width);
const room = centredLeft - (visibleFrame.x + TOOLBAR_PANEL_GAP);
if (needed > 0 && needed > room) return null;
shift = Math.max(0, needed);
}
const style = visibleFrame ? ({
"--canvas-visible-bottom-inset": `calc(100% - ${visibleFrame.y + visibleFrame.height}px)`,
"--canvas-toolbar-shift": `${shift}px`,
} as CSSProperties) : undefined;
const views = CANVAS_VIEW_ORDER;
return (
<div className="canvas-toolbar" role="toolbar" aria-label="Canvas tools" style={style}>
<div ref={setElement} className="canvas-toolbar" role="toolbar" aria-label="Canvas tools" style={style}>
{/* The contents grow with --ui-scale; the bar itself keeps its exact place. */}
<div className="canvas-toolbar-inner">
<div className="toolbar-group" role="group" aria-label="Canvas actions">
@@ -96,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>
);
@@ -12,7 +12,8 @@ export type TransitionEdgeData = {
transitionCount: number;
active: boolean;
primary: boolean;
dimmed: boolean;
/** Another screen is selected: the edge steps back to a hairline, so the selection's own stand out. */
quiet: boolean;
sourceOnly?: boolean;
previousSource?: boolean;
tooltip?: string;
@@ -39,9 +40,10 @@ export function TransitionEdge(props: EdgeProps<TransitionGraphEdge>) {
curvature: 0.24,
});
const emphasized = Boolean(props.data?.active || props.selected || hovered);
const dimmed = Boolean(props.data?.dimmed && !emphasized);
const quiet = Boolean(props.data?.quiet && !emphasized);
const stroke = emphasized
? "var(--accent)"
: quiet ? "var(--border-subtle)"
: props.data?.previousSource ? "var(--danger)" : props.data?.primary ? "var(--graph-line)" : "var(--graph-line-soft)";
return (
@@ -66,9 +68,8 @@ export function TransitionEdge(props: EdgeProps<TransitionGraphEdge>) {
style={{
...props.style,
stroke,
strokeWidth: emphasized ? 2.2 : props.data?.primary ? 1.15 : 0.9,
strokeWidth: emphasized ? 2.5 : quiet ? 1 : props.data?.primary ? 1.15 : 0.9,
strokeDasharray: props.data?.sourceOnly ? "6 5" : emphasized || props.data?.primary ? undefined : "4 7",
opacity: dimmed ? 0.12 : 1,
}}
/>
</>
@@ -107,6 +107,13 @@ export function ZoomBridge(props: {
publishZoom(Math.round(zoom * 100) / 100);
}, [props.cameraReady, zoom]);
// What a stroke that must stay legible at any zoom divides by (the Map's selection ring). It
// moves in quarter-octave steps, so a pinch restyles the canvas a few times, not every frame.
const strokeZoom = 2 ** (Math.round(Math.log2(zoom) * 4) / 4);
useEffect(() => {
canvas?.style.setProperty("--canvas-zoom", String(strokeZoom));
}, [canvas, strokeZoom]);
useEffect(() => {
// Re-registering after selection changes publishes the new capability to the zoom menu.
// Reading through getNodes keeps the commands themselves on the latest canvas snapshot.
@@ -490,9 +490,9 @@
the size a changed screen's is. */
.sidebar-review-off .variant-preview.has-image-ratio { width: min(100%, calc(70dvh * var(--preview-aspect))); }
.sidebar-review-stage {
/* Two frames and a 12px gap share the panel's width. One frame takes the whole width, up to
most of the window's height. */
--compare-frame-height: calc((100cqw - 12px) / 2 / var(--compare-aspect));
/* Two frames and a 12px gap share the panel's width, up to most of the window's height (a wide
panel would otherwise push What changed below the fold). One frame takes the whole width. */
--compare-frame-height: min(calc((100cqw - 12px) / 2 / var(--compare-aspect)), 70dvh);
gap: 12px;
}
.sidebar-review-stage.mode-swipe,
@@ -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(() => {
@@ -0,0 +1,183 @@
import {
useCallback, useRef, useSyncExternalStore, type CSSProperties, type KeyboardEvent, type PointerEvent, type RefObject,
} from "react";
import {
clampInspectorWidth, getToolbarRoom, inspectorWidthBounds, INSPECTOR_WIDTH_MAX, INSPECTOR_WIDTH_MIN, INSPECTOR_WIDTH_STEP,
setInspectorWidth, subscribeToToolbarRoom, useInspectorWidth,
type InspectorWidthBounds,
} from "../../utils/inspector-width";
/** On the root while the edge is dragged, so the whole page keeps the resize cursor and selects nothing. */
const RESIZING_CLASS = "inspector-resizing";
/** The chrome's zoom (`--ui-scale`): pointer distances are in window pixels, the panel's width in its own. */
function uiScale(): number {
const raw = parseFloat(getComputedStyle(document.documentElement).getPropertyValue("--ui-scale"));
return Number.isFinite(raw) && raw > 0 ? raw : 1;
}
/** The panel's width in its own pixels: the reader's, else the stylesheet's default for this window. */
function panelWidth(panel: HTMLElement): number {
return parseFloat(getComputedStyle(panel).width) || 0;
}
function defaultWidth(): number {
return window.matchMedia("(max-width: 1180px)").matches ? 320 : 400;
}
/** The panel's widest and default widths follow the window (and `--ui-scale`, which follows it too). */
function subscribeToWindow(onChange: () => void): () => void {
window.addEventListener("resize", onChange);
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 currentBounds().max;
}
type Drag = {
pointerId: number;
startX: number;
startWidth: number;
scale: number;
bounds: InspectorWidthBounds;
last: number;
/** The panel's own `--inspector-width` before the drag, put back when the drag changes nothing. */
inline: string;
};
/**
* Makes the Inspector's left edge a splitter. A drag moves the edge live (the width is written to
* the panel's `--inspector-width` directly, so nothing re-renders per pointer move) and is kept
* when the pointer lifts; arrow keys move it a step; Home and End take it to its narrowest and
* widest; a double-click returns it to the default.
*/
export function useInspectorResize(panelRef: RefObject<HTMLElement | null>) {
const width = useInspectorWidth();
const widest = useSyncExternalStore(subscribeToBounds, widestWidth, () => INSPECTOR_WIDTH_MAX);
const fallback = useSyncExternalStore(subscribeToWindow, defaultWidth, () => 400);
const drag = useRef<Drag | null>(null);
// Every way a drag can stop ends here, once: the pointer lifting, the browser taking the pointer
// back, the window losing focus, or the edge itself going away (the Inspector closed mid-drag).
const endDrag = useCallback(() => {
const state = drag.current;
if (!state) return;
drag.current = null;
document.documentElement.classList.remove(RESIZING_CLASS);
if (state.last !== state.startWidth) {
setInspectorWidth(state.last);
return;
}
// Nothing changed, so nothing re-renders to replace the width the drag wrote.
const panel = panelRef.current;
if (!panel) return;
if (state.inline) panel.style.setProperty("--inspector-width", state.inline);
else panel.style.removeProperty("--inspector-width");
}, [panelRef]);
const handleRef = useCallback((element: HTMLElement | null) => {
if (!element) return;
window.addEventListener("blur", endDrag);
return () => {
window.removeEventListener("blur", endDrag);
endDrag();
};
}, [endDrag]);
const onPointerDown = (event: PointerEvent<HTMLElement>) => {
const panel = panelRef.current;
if (event.button !== 0 || !panel) return;
const scale = uiScale();
const startWidth = panelWidth(panel);
drag.current = {
pointerId: event.pointerId, startX: event.clientX, startWidth, scale,
bounds: currentBounds(), last: startWidth,
inline: panel.style.getPropertyValue("--inspector-width"),
};
event.currentTarget.setPointerCapture(event.pointerId);
document.documentElement.classList.add(RESIZING_CLASS);
event.preventDefault();
};
const onPointerMove = (event: PointerEvent<HTMLElement>) => {
const state = drag.current;
const panel = panelRef.current;
if (!state || state.pointerId !== event.pointerId || !panel) return;
// A release the handle never heard about.
if (event.buttons === 0) {
endDrag();
return;
}
// The edge is on the left: moving the pointer left widens the panel.
const next = clampInspectorWidth(state.startWidth + (state.startX - event.clientX) / state.scale, state.bounds);
if (next === state.last) return;
state.last = next;
panel.style.setProperty("--inspector-width", `${next}px`);
};
const onPointerEnd = (event: PointerEvent<HTMLElement>) => {
const state = drag.current;
if (!state || state.pointerId !== event.pointerId) return;
if (event.currentTarget.hasPointerCapture(event.pointerId)) event.currentTarget.releasePointerCapture(event.pointerId);
endDrag();
};
const onKeyDown = (event: KeyboardEvent<HTMLElement>) => {
const panel = panelRef.current;
if (!panel) return;
const bounds = currentBounds();
const current = panelWidth(panel);
let next: number;
switch (event.key) {
case "ArrowLeft": next = current + INSPECTOR_WIDTH_STEP; break;
case "ArrowRight": next = current - INSPECTOR_WIDTH_STEP; break;
case "Home": next = bounds.min; break;
case "End": next = bounds.max; break;
default: return;
}
event.preventDefault();
event.stopPropagation();
// A key that cannot move the edge (End at a smaller window's cap) keeps the saved width.
next = clampInspectorWidth(next, bounds);
if (next !== Math.round(current)) setInspectorWidth(next);
};
// The saved width is the reader's preference; the panel takes as much of it as this window allows.
const bounds = { min: INSPECTOR_WIDTH_MIN, max: widest };
const shown = width === undefined ? undefined : clampInspectorWidth(width, bounds);
const style = (shown === undefined ? undefined : { "--inspector-width": `${shown}px` }) as CSSProperties | undefined;
const handleProps = {
role: "separator",
"aria-orientation": "vertical",
"aria-label": "Resize inspector",
"aria-valuemin": bounds.min,
"aria-valuemax": bounds.max,
"aria-valuenow": shown ?? fallback,
title: "Drag to resize. Double-click to reset.",
tabIndex: 0,
ref: handleRef,
onPointerDown,
onPointerMove,
onPointerUp: onPointerEnd,
onPointerCancel: onPointerEnd,
onLostPointerCapture: endDrag,
onKeyDown,
onDoubleClick: () => setInspectorWidth(undefined),
} as const;
return { style, handleProps };
}
+15 -19
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";
@@ -14,6 +14,7 @@ import { setOutlinesShown, useOutlinesShown } from "../compare/compare-section";
import { AutoHideScrollArea } from "../shared/auto-hide-scroll-area";
import { usePhoneLayout } from "../../utils/phone-layout";
import { useDragToDismiss } from "../phone/phone-chrome";
import { useInspectorResize } from "./inspector-resize";
type RightPanelProps = {
index: MapIndex;
@@ -36,6 +37,9 @@ export function RightPanel(props: RightPanelProps) {
// On a phone the panel is a bottom sheet; dragging its header down closes it.
const phone = usePhoneLayout();
const drag = useDragToDismiss(props.onToggleCollapsed);
// On a desktop its left edge is a splitter; the sheet keeps the window's width.
const panelRef = useRef<HTMLElement>(null);
const resize = useInspectorResize(panelRef);
const selectedPath = props.screen ? displayPathForScreen(props.screen) : undefined;
const screenDiff = props.screen ? props.diff?.screens.get(props.screen.id) : undefined;
// Compare opens only a screen it reviews: a changed screen in the review order, not a state
@@ -55,36 +59,28 @@ 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 className="right-panel" data-drag-sheet aria-label="Inspector panel">
<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} />}
<header className="right-head" {...(phone ? drag : {})}>
{phone ? <span className="right-sheet-grabber" aria-hidden="true" /> : null}
{phone ? panelButton : null}
+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 -2
View File
@@ -531,10 +531,10 @@
.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. */
max-width: none;
position: fixed;
z-index: 120;
inset: 0;
+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);
+34 -19
View File
@@ -31,6 +31,7 @@ import { arrowsOwnedBy, mapKeyDirection, mapKeyEntry, mapKeyTarget, type MapKeyD
import { createKeyHold } from "../../utils/key-hold";
const HOVER_CLEAR_DELAY = 180;
const PRESSABLE = 'button, a, summary, [role="button"]';
const MAP_LAYOUT_REVISION = "flat-v1";
const MAP_FIT_VIEW_OPTIONS = {
padding: 0.04,
@@ -115,8 +116,8 @@ function ScreenNodeCard({ data, selected }: NodeProps<ScreenGraphNode>) {
imageHeight={data.screenshotSize?.imageHeight ?? data.frame.screen.height}
placeholderSize={data.frame.screen}
loading="lazy"
// The route heads the card, so the tooltip goes below it.
tooltipPlacement="bottom"
// The ring says which screen is which; a click opening it in the Inspector needs no tooltip.
inspectorTooltip={false}
leading={<Handle type="target" position={horizontal ? Position.Left : Position.Top} className="graph-handle" />}
trailing={<Handle type="source" position={horizontal ? Position.Right : Position.Bottom} className="graph-handle" />}
onMouseEnter={() => data.onHover(data.screen.id)}
@@ -342,8 +343,9 @@ function projectionElements(
const edges: TransitionGraphEdge[] = structure.groups.map((group) => {
const hierarchyEdge = structure.primaryEdgeKeys.has(group.key);
const connected = group.from === selectedScreenId || group.to === selectedScreenId;
const dimmed = false;
const active = connected;
// While a screen is selected, every other transition quiets to a hairline; cards never fade.
const quiet = Boolean(selectedScreenId) && !connected;
const sourceOnly = group.transitionIds.length === 0 && Boolean(group.sourceEdges?.length);
const previousSource = group.sourceRevision === "baseline";
const removed = previousSource || (!group.synthetic && diff?.screens.get(group.to)?.status === "removed");
@@ -356,25 +358,26 @@ function projectionElements(
const primary = hierarchyEdge;
const stroke = active
? "var(--accent)"
: quiet ? "var(--border-subtle)"
: removed ? "var(--danger)" : primary ? "var(--graph-line)" : "var(--graph-line-soft)";
return {
id: edgeElementId(group.key),
source: group.from,
target: group.to,
type: "transition",
className: `${hierarchyEdge ? "graph-edge-primary" : "graph-edge-secondary"}${sourceOnly ? " graph-edge-source" : ""}${previousSource ? " graph-edge-source-baseline" : ""}${active ? " graph-edge-active" : ""}${dimmed ? " graph-edge-dimmed" : ""}`,
className: `${hierarchyEdge ? "graph-edge-primary" : "graph-edge-secondary"}${sourceOnly ? " graph-edge-source" : ""}${previousSource ? " graph-edge-source-baseline" : ""}${active ? " graph-edge-active" : ""}${quiet ? " graph-edge-quiet" : ""}`,
markerEnd: {
type: MarkerType.ArrowClosed,
width: active || hierarchyEdge ? 14 : 11,
height: active || hierarchyEdge ? 14 : 11,
width: active || (hierarchyEdge && !quiet) ? 14 : 11,
height: active || (hierarchyEdge && !quiet) ? 14 : 11,
color: stroke,
},
style: {
stroke,
strokeWidth: active ? 2.2 : hierarchyEdge ? 1.15 : 0.9,
strokeWidth: active ? 2.5 : quiet ? 1 : hierarchyEdge ? 1.15 : 0.9,
strokeDasharray: !hierarchyEdge && !active && !removed ? "4 7" : undefined,
},
data: { label, transitionCount: group.transitionIds.length, active, primary, dimmed, sourceOnly, previousSource, ...(tooltip ? { tooltip } : {}) },
data: { label, transitionCount: group.transitionIds.length, active, primary, quiet, sourceOnly, previousSource, ...(tooltip ? { tooltip } : {}) },
// React Flow renders a positive edge z-index above root nodes. Keep every connection in
// the base edge layer so selected/highlighted paths still pass behind screen imagery.
zIndex: 0,
@@ -433,7 +436,7 @@ function sameTransitionEdge(a: TransitionGraphEdge, b: TransitionGraphEdge) {
&& a.data?.transitionCount === b.data?.transitionCount
&& a.data?.active === b.data?.active
&& a.data?.primary === b.data?.primary
&& a.data?.dimmed === b.data?.dimmed;
&& a.data?.quiet === b.data?.quiet;
}
function reuseUnchangedElements(
@@ -557,7 +560,8 @@ function ConnectionCanvas(props: MapViewProps) {
}, [applyHover]);
// The arrow keys (or h j k l) walk the map from the selected screen: along an edge in the
// layout's flow, across to the neighbour on the same rank otherwise. With nothing selected they
// enter the map at its edge, as on the Screens page. A held key keeps walking.
// enter the map at its edge, as on the Screens page. A held key keeps walking. Return opens the
// selection in the Inspector.
const { selectedScreenId } = props;
const selectedRef = useRef(selectedScreenId);
selectedRef.current = selectedScreenId;
@@ -568,22 +572,39 @@ function ConnectionCanvas(props: MapViewProps) {
if (!structure) return undefined;
return from ? mapKeyTarget(structure, from, direction) : mapKeyEntry(structure, direction);
};
// A click leaves the keyboard focus on the clicked screen's button, where Return would press it
// and open that screen again. A walk lets go of it, so Return reaches the screen walked to.
const walkTo = (id: string) => {
const focused = document.activeElement;
if (focused instanceof HTMLElement && surfaceRef.current?.contains(focused)) focused.blur();
selectScreen(id);
};
const onKeyDown = (event: KeyboardEvent) => {
hold.interrupt(event);
if (event.repeat && hold.holding(event.code)) { event.preventDefault(); return; }
if (event.defaultPrevented || !shortcutsLive(event) || arrowsOwnedBy(event.target)) return;
if (event.key === "Enter") {
// A focused button or link keeps its own Return; elsewhere on the page it opens the selection.
const target = event.target instanceof Element ? event.target : null;
const selected = selectedRef.current;
if (!selected || event.isComposing || event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return;
if (target && target !== document.body && (target.closest(PRESSABLE) || !surfaceRef.current?.contains(target))) return;
event.preventDefault();
selectScreen(selected);
return;
}
const direction = mapKeyDirection(event);
if (!direction) return;
if (!structureRef.current) return;
event.preventDefault();
let at = move(direction, selectedRef.current);
if (!at) return;
selectScreen(at);
walkTo(at);
hold.begin(event.code, () => {
const target = move(direction, at);
if (!target) return false;
at = target;
selectScreen(target);
walkTo(target);
return true;
});
};
@@ -636,9 +657,6 @@ 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();
const selectedScreenVisible = Boolean(
props.selectedScreenId && layout.nodes.some((node) => node.id === props.selectedScreenId),
);
if (props.map.screens.length === 0) {
const blockers = props.map.gaps.filter((gap) => gap.status === "open" && !gap.screenId).map((gap) => gap.message);
return (
@@ -656,10 +674,7 @@ function ConnectionCanvas(props: MapViewProps) {
<div ref={surfaceRef} className="connection-canvas-surface map-surface">
<CanvasStage
ariaLabel="Screen map"
className={[
"map-canvas",
selectedScreenVisible ? "screen-selection-active" : "",
].filter(Boolean).join(" ")}
className="map-canvas"
nodes={layout.nodes}
edges={layout.edges}
nodeTypes={NODE_TYPES}
+152 -108
View File
@@ -110,7 +110,6 @@
/* How far an item the Changes filter does not cover falls back. Low enough to read as
background at a glance, high enough that the canvas keeps its shape. */
--dim-out: 0.35;
--hover-neighbour-frame: color-mix(in srgb, var(--accent) 55%, var(--border-subtle));
--shadow-xs: 0 1px 3px rgba(0, 0, 0, 0.025), 0 1px 2px rgba(0, 0, 0, 0.05);
--shadow-md: 0 10px 20px rgba(0, 0, 0, 0.1), 0 3px 6px rgba(0, 0, 0, 0.05);
@@ -134,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);
@@ -305,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),
@@ -326,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) {
@@ -351,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;
}
@@ -461,6 +451,8 @@ code {
--graph-line-soft: #c5c7ce;
/* One flat fill for a group — no border, no second tone inside it. */
--canvas-group: #f5f5f6;
/* The ring a hovered Map card takes: a step past the border scale, short of the connectors. */
--hover-ring: #b9bbc6;
color: var(--text);
background: var(--screen);
}
@@ -480,6 +472,7 @@ code {
--graph-line: #696e77;
--graph-line-soft: #3f4349;
--canvas-group: #18191b;
--hover-ring: #5a6169;
}
/* The canvas is a fixed map: dragging anywhere pans, while clicking an object selects it. */
.graph-canvas .canvas-tool-pan,
@@ -499,27 +492,14 @@ code {
.graph-canvas .transition-edge-hitarea { cursor: pointer; pointer-events: stroke; }
.graph-canvas .transition-edge-path { transition: stroke 100ms ease, stroke-width 100ms ease, opacity 140ms ease; }
.graph-canvas .graph-edge-secondary { opacity: 0.72; }
.graph-canvas .graph-edge-dimmed { opacity: 0.14; }
.graph-canvas .graph-edge-active { opacity: 1; }
.graph-canvas .react-flow__node { transition: opacity 180ms ease, filter 180ms ease; }
.graph-canvas .canvas-focus-animating .react-flow__node { transition: none; }
/* Focus: what the chosen state does not cover only steps back, so the map is still readable. */
.graph-canvas .react-flow__node.graph-node-muted { opacity: var(--dim-out); --map-card-opacity: var(--dim-out); }
/* A route-selected screenshot stays visually anchored while the surrounding screenshots recede.
They fade as focus dims them, by opacity alone: a filter would grey the card's opaque backing.
Summary cards retain their normal contrast so the selected screen's semantic context is legible. */
.map-canvas.screen-selection-active .react-flow__node-screen:not(.selected) {
opacity: var(--dim-out);
--map-card-opacity: var(--dim-out);
}
.map-canvas.screen-selection-active .react-flow__node-screen:not(.selected):hover,
.map-canvas.screen-selection-active .react-flow__node-screen:not(.selected):focus-within {
opacity: 1;
--map-card-opacity: 1;
}
/* Hover never recedes anything, but where focus or a selection has already dimmed the map, the
hovered screen and the screens it connects to come back up, with the transitions between them,
so the neighbourhood reads. These come after both dimming rules so the pointer's context wins. */
/* Hover never recedes anything, but where the Changes filter has dimmed the map, the hovered
screen and the screens it connects to come back up, with the transitions between them, so the
neighbourhood reads. These come after the dimming rule so the pointer's context wins. */
.connection-canvas-surface.canvas-hovering .react-flow__node-screen.graph-node-hover-related {
opacity: 1;
--map-card-opacity: 1;
@@ -687,7 +667,7 @@ code {
/* Hover and selection draw a 3px ring in the accent colour: the 1px border recoloured plus a 2px
shadow outside it, so the image keeps its size (a thicker border would shrink the picture inside
its box). Changed screens keep their own colour at the same weight: the diff rules below win on
specificity. */
specificity. The Map leaves the border to the status and rings the card from outside instead. */
.screen-node-image:hover img,
.screen-screenshot-card.selected .screen-node-image img { border-color: var(--accent); box-shadow: 0 0 0 2px var(--accent); }
.screen-node-image:hover > .image-placeholder,
@@ -707,8 +687,8 @@ code {
border-radius: 17px;
pointer-events: none;
}
/* Selection needs no ring: the canvas dims every other screen. The highlight ring stays for the
transient pointer-over state that panels project onto the canvas. */
/* Selection needs no overlay: the Map rings the screenshot and Screens frames the card. The
highlight ring stays for the transient pointer-over state that panels project onto the canvas. */
.canvas-active-frame.is-highlighted::after {
border-color: var(--accent);
box-shadow: 0 0 24px color-mix(in srgb, var(--accent) 24%, transparent);
@@ -723,10 +703,9 @@ code {
pointer-events: none;
}
/* A screen's handles are ports on its frame: they take the frame colour, whether that is the
status colour of a changed screen or the accent of a hovered or selected one, and a ring in
the canvas colour keeps them legible as connection points on the border. */
status colour of a changed screen or the accent of a selected one, and a ring in the canvas
colour keeps them legible as connection points on the border. */
.screen-screenshot-card { --screen-frame: var(--graph-line); }
.screen-screenshot-card:has(.screen-node-image:hover),
.screen-screenshot-card.selected,
.screen-screenshot-card.highlighted { --screen-frame: var(--accent); }
.screen-screenshot-card:is(.diff-added, .diff-modified, .diff-removed) { --screen-frame: var(--diff); }
@@ -738,23 +717,48 @@ code {
opacity: 1;
}
/* Hover is transient canvas state. Nothing recedes: the pointer's screen gets its ring, the
transitions into and out of it turn accent, and the screens at their other ends take a tinted
frame, so the neighbourhood reads without the rest of the map changing. Only the symmetric
difference of related nodes/edges receives a class, avoiding a React commit across the graph. */
.connection-canvas-surface.canvas-hovering .graph-edge-hover-related .transition-edge-path {
stroke: var(--accent) !important;
stroke-width: 2.2 !important;
/* A Map card's border is its status alone. Selection rings it from outside instead: an accent
ring past a gap in the canvas colour, outside the status border, with a soft lift; hover draws
the same ring in grey. The ring scales with the canvas, so below a readable zoom its unit grows
to keep it about a screen pixel and a half wide (--canvas-zoom, set by the zoom bridge). */
.map-surface .screen-screenshot-card {
--ring-unit: clamp(1px, 0.6px / var(--canvas-zoom, 1), 6px);
--ring-status: 0px;
}
.map-surface .screen-screenshot-card:is(.diff-added, .diff-modified, .diff-removed) { --ring-status: 2px; }
.map-surface .screen-screenshot-card .screen-node-image :is(img, .image-placeholder) {
border-color: var(--border-subtle);
box-shadow: none;
}
.map-surface .react-flow__node-screen:is(.selected, .graph-node-hover-subject) .screen-screenshot-card .screen-node-image :is(img, .image-placeholder) {
box-shadow:
0 0 0 var(--ring-status) var(--diff, transparent),
0 0 0 calc(var(--ring-status) + 4 * var(--ring-unit)) var(--screen),
0 0 0 calc(var(--ring-status) + 6.5 * var(--ring-unit)) var(--ring-color),
var(--ring-lift, 0 0 transparent);
}
.map-surface .react-flow__node-screen.graph-node-hover-subject { --ring-color: var(--hover-ring); }
.map-surface .react-flow__node-screen.selected {
--ring-color: var(--accent);
--ring-lift: 0 calc(10 * var(--ring-unit)) calc(28 * var(--ring-unit)) color-mix(in srgb, var(--accent) 18%, transparent);
}
.map-surface .react-flow__node-screen.selected .screen-node-title { color: var(--accent-strong); }
/* Keyboard focus is dashed, past where a ring would sit, so it never reads as either. */
.map-surface .screen-screenshot-target:focus-visible {
outline: 2px dashed var(--accent-strong) !important;
outline-offset: calc(var(--ring-status) + 9 * var(--ring-unit)) !important;
filter: none !important;
}
/* Hover is transient canvas state. Nothing recedes: the pointer's screen takes its grey ring and
the transitions into and out of it darken. Only the symmetric difference of related
nodes/edges receives a class, avoiding a React commit across the graph. A selected screen's
transitions stay accent. */
.connection-canvas-surface.canvas-hovering .graph-edge-hover-related:not(.graph-edge-active) .transition-edge-path {
stroke: var(--tertiary) !important;
stroke-width: 2 !important;
stroke-dasharray: none !important;
}
.connection-canvas-surface.canvas-hovering .react-flow__node-screen.graph-node-hover-related:not(.graph-node-hover-subject)
.screen-screenshot-card:not(.selected, .diff-added, .diff-modified, .diff-removed) {
--screen-frame: var(--hover-neighbour-frame);
}
.connection-canvas-surface.canvas-hovering .react-flow__node-screen.graph-node-hover-related:not(.graph-node-hover-subject)
.screen-screenshot-card:not(.selected, .diff-added, .diff-modified, .diff-removed) .screen-node-image :is(img, .image-placeholder) {
border-color: var(--hover-neighbour-frame);
}
/* Semantic Map: an area is a meaningful destination, never an anonymous "X states" step. */
.semantic-summary-node {
@@ -928,7 +932,7 @@ code {
/* The phone map's open hint. The first tap there only selects, so the pill sits in the middle of
the selected screenshot (always on the image whatever the slot's shape) and says what the next
tap does. In a wider window the card's tooltip carries the message and nothing covers the image. */
tap does. In a wider window a click opens the Inspector at once and nothing covers the image. */
.screen-screenshot-target { cursor: pointer; }
.screen-open-hint {
position: absolute;
@@ -954,7 +958,7 @@ code {
.screen-open-hint > svg { width: 14px; height: 14px; flex: none; }
/* Only the phone layout's map shows the pill, on the selected screen, where a second tap or click
opens the Inspector. That layout is a width, not a device, and has no tooltips, so a narrow
desktop window shows it too. Elsewhere the screenshot button's tooltip says it instead. */
desktop window shows it too. */
.phone-layout .map-canvas .screen-screenshot-card.selected .screen-open-hint {
display: inline-flex;
animation: screen-open-hint-in 140ms ease-out;
@@ -998,7 +1002,7 @@ code {
border-radius: calc(14px * var(--ui-scale));
background: var(--surface);
box-shadow: var(--floating-chrome-shadow);
transform: translateX(-50%);
transform: translateX(calc(-50% - var(--canvas-toolbar-shift, 0px)));
view-transition-name: canvas-toolbar;
}
.canvas-toolbar-inner { display: flex; align-items: center; gap: 2px; zoom: var(--ui-scale); }
@@ -1105,7 +1109,10 @@ code {
z-index: 100;
display: flex;
flex: none;
width: 400px;
/* The reader's own width when they have dragged the edge (utils/inspector-width.ts), else the
default; never more than half the window, so the canvas keeps the other half. */
width: var(--inspector-width, 400px);
max-width: 50%;
height: 100%;
min-height: 0;
flex-direction: column;
@@ -1117,33 +1124,35 @@ code {
/* Two Diff previews, their 8px gap, and the 14px side insets must fit this same width. */
--inspector-shared-preview-max-width: calc((100cqw - 36px) / 2);
}
/* 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;
/* The panel's left edge is a splitter: a 10px strip over the border, quiet until it is hovered,
dragged or focused, when the border thickens into the accent line. */
.right-panel-resize {
position: absolute;
z-index: 1;
top: 0;
bottom: 0;
left: -5px;
width: 10px;
cursor: col-resize;
touch-action: none;
outline: none;
}
.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-panel-resize::before {
position: absolute;
top: 0;
bottom: 0;
left: 4px;
width: 2px;
background: var(--accent);
content: "";
opacity: 0;
transition: opacity var(--toolbar-motion) var(--toolbar-easing) 120ms;
}
.right-panel-resize:hover::before,
.right-panel-resize:focus-visible::before,
.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; }
.right-head {
display: flex;
flex: none;
@@ -1202,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;
@@ -1213,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;
@@ -1260,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;
@@ -2056,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 {
@@ -2202,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;
@@ -2330,7 +2374,7 @@ html [data-sonner-toaster][data-sonner-theme] {
@keyframes tooltip-in { from { opacity: 0; } }
@media (max-width: 1180px) {
.right-panel { width: 320px; }
.right-panel { width: var(--inspector-width, 320px); }
}
@media (max-width: 900px) {
+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) {
+83
View File
@@ -0,0 +1,83 @@
import { useSyncExternalStore } from "react";
import { optionalStorage } from "./embedded-report";
const INSPECTOR_WIDTH_STORAGE_KEY = "expo-explore:inspector-width";
/** Below this the Before/After pair no longer reads; above the maximum the canvas is the one squeezed. */
export const INSPECTOR_WIDTH_MIN = 320;
export const INSPECTOR_WIDTH_MAX = 800;
/** How far one arrow key press moves the panel's edge. */
export const INSPECTOR_WIDTH_STEP = 16;
const listeners = new Set<() => void>();
/** The choice made this visit: storage can be denied (a private window), and the drag must still hold. `null` is a reset. */
let chosen: number | null | undefined;
function parseWidth(value: string | null): number | undefined {
if (value === null) return undefined;
const width = Number(value);
return Number.isFinite(width) && width > 0 ? width : undefined;
}
function stored(): number | undefined {
if (chosen !== undefined) return chosen ?? undefined;
return parseWidth(optionalStorage.getItem(INSPECTOR_WIDTH_STORAGE_KEY));
}
/** Sets the Inspector's width in unscaled CSS pixels, or `undefined` to return to the default, and remembers it where it can. */
export function setInspectorWidth(width: number | undefined) {
chosen = width ?? null;
if (width === undefined) optionalStorage.removeItem(INSPECTOR_WIDTH_STORAGE_KEY);
else optionalStorage.setItem(INSPECTOR_WIDTH_STORAGE_KEY, String(width));
for (const listener of listeners) listener();
}
/** The reader's Inspector width, or `undefined` while the panel keeps its default width. */
export function useInspectorWidth(): number | undefined {
return useSyncExternalStore(
(onChange) => {
listeners.add(onChange);
return () => listeners.delete(onChange);
},
stored,
() => 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, 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, 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 {
return Math.round(Math.min(bounds.max, Math.max(bounds.min, width)));
}
+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"),