Compare commits

..
Author SHA1 Message Date
Brent Vatne 005ca2d0cf Name euxy's PR by its repository in comments 2026-10-15 20:40:11 -07:00
Brent Vatne 05f85ca9d9 Make measured moves exact and never hide a change
Review fixes for measured outlines:

- A region that moved and also changed is not a move: after aligning it by
  the move, three or more pixels still differing by over 140 in any channel
  mean its content changed (re-rasterized text stays under about 125; new
  content is about 200). Colour-only changes are caught per channel.
- Near-tie fits go to the smallest move, so content that is the same all along
  one axis (full-width bars, hairlines) is measured; a second fit nearly as
  good two or more pixels away (repeating content) leaves the region
  unmeasured rather than reporting a wrong direction.
- The vertical search reaches 20 pixels, since drift adds up down long
  screens; sub-pixel offsets come from whole-number steps, so moves up and
  down are judged alike; moves are measured only while the comparison's time
  budget lasts.
- Every region the comparison found is measured, not only the eight it
  publishes, and allRegionsMoved records that all of them moved. The Viewer
  says "Nothing on this screen changed content" only then, and only when no
  other finding remains; it hides only the generic visual finding.
- Each outline carries one number, to a tenth: areas merge only when their
  moves are within a third of each other and span at most half a point
  together, and a moved outline never grows around a changed area.
- The outline and measurement switches keep the choice in memory where
  browser storage is denied, and the Inspector's side-by-side places Before
  outlines too.
2026-10-15 20:35:17 -07:00
Brent Vatne 0240437a4f Label outlines with how far moved areas moved
A layout that grew by a device pixel marks every edge below it as changed, so
an SDK upgrade reads as dozens of modified screens with nothing visible to say
why. CI now measures, for each changed region, the shift that best lines
Before up with After; when one shift explains the region, the report records
it as the region's shift (screenshot pixels, right and down positive). New
text, another colour or a caret is not a move. A move of half a pixel or less
needs a quarter of the difference explained (text re-rasterizes rather than
moves at that size), a larger one 60%, and a best fit at the edge of the search
is rejected, since repeating rows line up with themselves a pitch away.

With Highlight on, the Viewer draws a moved area dashed, where its content is
on each side, labelled with how far it moved ("↑4pt", "↓1–2pt"); areas that
moved together merge into one outline. When every area only moved, What
changed says the layout shifted and how far, in place of the generic visual
finding, and a Show measurements switch there turns the labels off in every
mode. iOS screenshots are one pixel per point; Android's are labelled in
screenshot pixels, since the report does not know the screen's density.
2026-10-15 19:48:19 -07:00
13 changed files with 37 additions and 424 deletions

No files matched your search

+2 -2
View File
@@ -1,12 +1,12 @@
{
"name": "@expo/explore",
"version": "0.19.4",
"version": "0.19.2",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "@expo/explore",
"version": "0.19.4",
"version": "0.19.2",
"license": "MIT",
"dependencies": {
"@expo/repack-app": "0.10.1",
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/explore",
"version": "0.19.4",
"version": "0.19.2",
"description": "Source-driven mobile app maps, deterministic CI capture, and visual reviews",
"license": "MIT",
"type": "module",
+4 -7
View File
@@ -406,13 +406,10 @@ test("the Screens tree folds by row, by keyboard, and all at once, and remembers
await tree.getByRole("button", { name: "Expand all" }).click();
await expect.poll(() => rows.count()).toBe(expandedRows);
// The tree names the folders, so the page beside it is one grid without section headings, in the tree's order.
await expect(page.locator(".screens-page .screens-section-head")).toHaveCount(0);
await expect(page.locator(".screens-page .screens-grid")).toHaveCount(1);
const treeOrder = await tree.locator(".screens-tree-row[data-screen-id]").evaluateAll(rows => rows.map(row => row.dataset.screenId));
const gridOrder = await page.locator(".screens-page .screens-cell").evaluateAll(cells => cells.map(cell => cell.dataset.screenId));
assert.ok(gridOrder.length > 1);
assert.deepEqual(gridOrder, treeOrder);
// Section headings name the folder, with the path beneath.
const onboarding = page.getByRole("region", { name: "Onboarding" });
await expect(onboarding.getByRole("heading", { level: 2 })).toHaveText("Onboarding");
await expect(onboarding.locator(".screens-section-head .path")).toHaveText("app/onboarding");
assert.deepEqual(errors, []);
});
+2 -96
View File
@@ -1309,100 +1309,7 @@ for (const canvas of ["map", "screens"] as const) {
});
}
test("← and → step through the Screens cards in page order, with focus, and leave the tree's arrows alone", async ({ page }) => {
await serveWorkspace(page);
await page.goto("/screens");
const grid = page.getByRole("main", { name: "Screens" });
await grid.getByRole("button", { name: /^All/ }).click();
const cells = grid.locator(".screens-grid .screens-cell");
const ids = await cells.evaluateAll(elements => elements.map(element => element.getAttribute("data-screen-id")!));
expect(ids.length).toBeGreaterThan(2);
const card = (id: string) => grid.locator(`.screens-cell[data-screen-id="${id}"] .screen-screenshot-card`);
const target = (id: string) => grid.locator(`.screens-cell[data-screen-id="${id}"] .screen-screenshot-target`);
// With nothing selected, → starts at the first card.
await expect(grid.locator(".screen-screenshot-card.selected")).toHaveCount(0);
await page.keyboard.press("ArrowRight");
await expect(card(ids[0]!)).toHaveClass(/selected/);
await expect(target(ids[0]!)).toBeFocused();
await page.keyboard.press("ArrowRight");
await expect(card(ids[1]!)).toHaveClass(/selected/);
await expect(target(ids[1]!)).toBeFocused();
await page.keyboard.press("ArrowRight");
await expect(card(ids[2]!)).toHaveClass(/selected/);
await page.keyboard.press("ArrowLeft");
await expect(card(ids[1]!)).toHaveClass(/selected/);
await expect(card(ids[2]!)).not.toHaveClass(/selected/);
// ↓ and ↑ move a row, to the card in the same column.
const tops = await cells.evaluateAll(elements => elements.map(element => Math.round(element.getBoundingClientRect().top)));
const columns = tops.filter(top => top === tops[0]).length;
if (ids.length > 1 + columns) {
await page.keyboard.press("ArrowDown");
await expect(card(ids[1 + columns]!)).toHaveClass(/selected/);
await expect(target(ids[1 + columns]!)).toBeFocused();
await page.keyboard.press("ArrowUp");
await expect(card(ids[1]!)).toHaveClass(/selected/);
}
// Held, → keeps stepping, as in Compare, and stops on release.
const selectedAt = async () => ids.indexOf((await grid.locator(".screens-cell:has(.screen-screenshot-card.selected)").getAttribute("data-screen-id"))!);
const from = await selectedAt();
await page.keyboard.down("ArrowRight");
await expect.poll(selectedAt, { timeout: 4000 }).toBeGreaterThanOrEqual(Math.min(ids.length - 1, from + 3));
await page.keyboard.up("ArrowRight");
const released = await selectedAt();
await page.waitForTimeout(500);
expect(await selectedAt()).toBe(released);
// Return opens the pick in the Inspector, from the card or from anywhere on the page.
const inspector = page.getByRole("complementary", { name: "Inspector panel" });
await expect(inspector).toBeHidden();
await page.keyboard.press("Enter");
await expect(inspector).toBeVisible();
await page.keyboard.press("Escape");
await expect(inspector).toBeHidden();
await page.evaluate(() => (document.activeElement as HTMLElement | null)?.blur());
await page.keyboard.press("Enter");
await expect(inspector).toBeVisible();
await page.keyboard.press("Escape");
await expect(inspector).toBeHidden();
// In the tree, ← and → fold and unfold rows; they do not step the cards.
const picked = await selectedAt();
const row = grid.locator(".screens-tree-row").first();
await row.focus();
await page.keyboard.press("ArrowLeft");
await expect(card(ids[picked]!)).toHaveClass(/selected/);
});
test("→ steps the Screens cards right after Screens is opened from the toolbar, and from a pick that Changed hides", async ({ page }) => {
await serveWorkspace(page);
await page.goto("/map");
await page.getByRole("group", { name: "Canvas view" }).getByRole("button", { name: "Screens", exact: true }).click();
const grid = page.getByRole("main", { name: "Screens" });
const cells = grid.locator(".screens-grid .screens-cell");
await expect(cells.first()).toBeVisible();
// Focus is still on the toolbar's Screens button.
await page.keyboard.press("ArrowRight");
await expect(cells.first().locator(".screen-screenshot-card")).toHaveClass(/selected/);
// Pick a screen that Changed hides, then show Changed: → goes to the next changed card after it in the tree.
await grid.getByRole("button", { name: /^All/ }).click();
const all = await cells.evaluateAll(elements => elements.map(element => element.getAttribute("data-screen-id")!));
await grid.getByRole("button", { name: /^Changed/ }).click();
const changed = await cells.evaluateAll(elements => elements.map(element => element.getAttribute("data-screen-id")!));
const hidden = all.find((id, position) => !changed.includes(id) && all.slice(position + 1).some(next => changed.includes(next)));
test.skip(!hidden, "the fixture has no unchanged screen before a changed one");
await grid.getByRole("button", { name: /^All/ }).click();
await grid.locator(`.screens-cell[data-screen-id="${hidden}"] .screen-screenshot-target`).click();
await grid.getByRole("button", { name: /^Changed/ }).click();
const expected = all.slice(all.indexOf(hidden!) + 1).find(id => changed.includes(id))!;
await page.keyboard.press("ArrowRight");
await expect(grid.locator(`.screens-cell[data-screen-id="${expected}"] .screen-screenshot-card`)).toHaveClass(/selected/);
});
test("reuses the Map screenshot card in Screens, with the route under the screenshot at the card's left edge", async ({ page }) => {
test("reuses the Map screenshot card visual in Screens, with the route at the card's left edge", async ({ page }) => {
await serveWorkspace(page);
await page.goto("/screens");
@@ -1430,9 +1337,8 @@ test("reuses the Map screenshot card in Screens, with the route under the screen
};
});
expect(layout.flexDirection).toBe("column");
// The card is the Map's, so the heading still comes first in the markup; Screens shows it as the card's footer.
expect(layout.headingBeforeImage).toBe(true);
expect(layout.headingTop).toBeGreaterThan(layout.imageTop);
expect(layout.headingTop).toBeLessThan(layout.imageTop);
expect(layout.titleLeftDelta).toBeLessThan(1);
}
+1 -15
View File
@@ -3,7 +3,7 @@ import test from "node:test";
const { tsImport } = await import("tsx/esm/api");
const { indexMap } = await tsImport("../../viewer/src/utils/model.ts", import.meta.url);
const { screenTree, treeScreenOrder } = await tsImport("../../viewer/src/utils/screen-tree.ts", import.meta.url);
const { screenTree } = await tsImport("../../viewer/src/utils/screen-tree.ts", import.meta.url);
const at = (second) => `2026-10-13T00:00:${String(second).padStart(2, "0")}.000Z`;
function screen(id, title, depth, extra = {}) {
@@ -49,20 +49,6 @@ test("with route files, sections follow the app directory and the tabs lead", ()
assert.deepEqual(folders, ["(tabs)/"]);
});
test("the screens' order is the tree's, depth first: a nested folder's screens come right after their parent's", () => {
// The folders are found as settings, feed, settings/security: sections keep that order, while the tree nests
// security under settings. The Screens grid and its arrow keys follow the tree, as the sidebar reads.
const screens = [screen("profile", "A profile", 1), screen("feed", "B feed", 1), screen("security", "C security", 1), screen("loose", "D loose", 1)];
const routeFiles = new Map([
["profile", "app/settings/profile.tsx"],
["feed", "app/feed/index.tsx"],
["security", "app/settings/security/index.tsx"],
]);
const tree = screenTree(screens, indexMap(map({ screens })), routeFiles);
assert.deepEqual(tree.sections.flatMap(section => section.screenIds), ["profile", "feed", "security", "loose"]);
assert.deepEqual(treeScreenOrder(tree), ["profile", "security", "feed", "loose"]);
});
test("a black-box exploration groups by the tab each screen was opened from", () => {
const screens = [
screen("seq", "Sequencer", 0),
+1 -17
View File
@@ -15,21 +15,6 @@ test("hints print modifiers in Apple's ⌥⇧⌘ order and as Ctrl+Alt+Shift els
assert.equal(formatShortcut(SHORTCUTS.camera.fit, true), "⇧1");
assert.equal(formatShortcut({ code: "KeyT", key: "T", mod: true, alt: true }, false), "Ctrl+Alt+T");
assert.equal(formatShortcut(SHORTCUTS.edit.redo, false), "Ctrl+Shift+Z");
// The Control key itself prints as ⌃ on a Mac, where ⌘ would be a different key.
assert.equal(formatShortcut(SHORTCUTS.canvasByNumber.screens, true), "⌃2");
assert.equal(formatShortcut(SHORTCUTS.canvasByNumber.screens, false), "Ctrl+2");
});
test("Ctrl+1, Ctrl+2 and Ctrl+3 reach Map, Screens and Compare with Control alone, never ⌘ (the browser's tab keys)", () => {
assert.equal(matchesShortcut(key("Digit1", { ctrlKey: true }), SHORTCUTS.canvasByNumber.map), true);
assert.equal(matchesShortcut(key("Digit2", { ctrlKey: true }), SHORTCUTS.canvasByNumber.screens), true);
assert.equal(matchesShortcut(key("Digit3", { ctrlKey: true }), SHORTCUTS.canvasByNumber.compare), true);
assert.equal(matchesShortcut(key("Digit1", { metaKey: true }), SHORTCUTS.canvasByNumber.map), false);
assert.equal(matchesShortcut(key("Digit1", { ctrlKey: true, metaKey: true }), SHORTCUTS.canvasByNumber.map), false);
assert.equal(matchesShortcut(key("Digit1", { ctrlKey: true, shiftKey: true }), SHORTCUTS.canvasByNumber.map), false);
// Compare's 1, 2, 3 (Split, Swipe, Flip) stay plain digits.
assert.equal(matchesShortcut(key("Digit1", { ctrlKey: true }), SHORTCUTS.compare.split), false);
assert.equal(matchesShortcut(key("Digit1"), SHORTCUTS.canvasByNumber.map), false);
});
test("a chord matches only its own modifiers, on either ⌘ or Ctrl", () => {
@@ -50,8 +35,7 @@ test("no two shortcuts share a chord", () => {
const seen = new Map();
for (const [group, entries] of Object.entries(SHORTCUTS)) {
for (const [name, shortcut] of Object.entries(entries)) {
// Off Apple keyboards ⌘ is Ctrl, so a Control chord clashes with the same ⌘ chord.
const chord = `${shortcut.code}:${Boolean(shortcut.mod || shortcut.ctrl)}:${Boolean(shortcut.alt)}:${Boolean(shortcut.shift)}`;
const chord = `${shortcut.code}:${Boolean(shortcut.mod)}:${Boolean(shortcut.alt)}:${Boolean(shortcut.shift)}`;
const clash = seen.get(chord);
assert.ok(!clash, `${group}.${name} repeats ${clash}`);
seen.set(chord, `${group}.${name}`);
+1 -5
View File
@@ -46,7 +46,6 @@ import {
type ThemePreference,
} from "./utils/navigation";
import {
CANVAS_NUMBER_KEYS,
matchesShortcut,
modalOpen,
SHORTCUTS,
@@ -143,10 +142,7 @@ const LEGACY_COLLAPSED_STORAGE_KEY = "expo-explore:panel-collapsed";
const RIGHT_COLLAPSED_STORAGE_KEY = "expo-explore:right-panel-collapsed";
// The shell's keyboard map, paired with what each key selects. Read as lists so a key and the
// thing it reaches stay one entry.
const CANVAS_KEYS = [
...Object.entries(SHORTCUTS.canvas),
...(CANVAS_NUMBER_KEYS ? Object.entries(SHORTCUTS.canvasByNumber) : []),
] as [CanvasView, Shortcut][];
const CANVAS_KEYS = Object.entries(SHORTCUTS.canvas) as [CanvasView, Shortcut][];
/** Before data loads there is no comparison to assume. A workspace reparses the URL on arrival. */
const EMPTY_ROUTE_CONTEXT: RouteContext = {
@@ -1,7 +1,7 @@
import { useEffect } from "react";
import { createPortal } from "react-dom";
import { X } from "lucide-react";
import { CANVAS_NUMBER_KEYS, formatShortcut, SHORTCUTS, type Shortcut } from "../../utils/shortcuts";
import { formatShortcut, SHORTCUTS, type Shortcut } from "../../utils/shortcuts";
import type { CanvasView } from "../../utils/navigation";
import { useModalDialog } from "../../hooks/use-modal-dialog";
@@ -63,9 +63,6 @@ export function shortcutGroups(context: ShortcutContext): Group[][] {
label: context.hasChanges ? "Map, Screens, Compare" : "Map, Screens",
keys: sections.map((section) => SHORTCUTS.canvas[section]),
},
...(CANVAS_NUMBER_KEYS
? [{ label: "The same, by their place in the toolbar", keys: sections.map((section) => SHORTCUTS.canvasByNumber[section]) }]
: []),
{ label: "Search screens", keys: [SHORTCUTS.app.search] },
...(context.handoff ? [{ label: "Hand off to AI", keys: [SHORTCUTS.app.handoff] }] : []),
...(context.hasChanges ? [{ label: "Changed screens menu", keys: [SHORTCUTS.app.changes] }] : []),
@@ -86,17 +83,9 @@ export function shortcutGroups(context: ShortcutContext): Group[][] {
{ label: "Close the inspector, then deselect", keys: ["Esc"] },
],
};
const screensGroup: Group = {
title: "Screens",
rows: [
{ label: "Move through the screens", keys: ["←", "→", "↑", "↓"] },
{ label: "Close the inspector, then deselect", keys: ["Esc"] },
],
};
const here: Group[] = context.canvas === "compare"
? [reviewGroup(context)]
: [...(context.review ? [reviewGroup(context)] : []), ...(context.canvas === "map" ? [mapGroup] : []),
...(context.canvas === "screens" ? [screensGroup] : []), CAMERA];
: [...(context.review ? [reviewGroup(context)] : []), ...(context.canvas === "map" ? [mapGroup] : []), CAMERA];
return [here, [goTo, view]];
}
-85
View File
@@ -184,91 +184,6 @@ button.screens-tree-row:hover { color: var(--text); background: var(--panel-hove
.screens-cell-via { overflow: hidden; color: var(--tertiary); font-size: 11px; text-overflow: ellipsis; white-space: nowrap; }
.screens-cell-elsewhere { color: var(--modified); font-size: 11px; font-weight: 600; }
/* ── Desktop grid ── */
/* One evenly spaced grid. Each screen is a card: the screenshot in a grey well and the route under it, with the
status as the tree's dot before it, the way file browsers show documents. Nothing is framed in the status colour,
so the page reads as a list of screens rather than a canvas of them. */
.screens-page:not(.phone) .screens-sections { display: block; padding-top: 0; }
.screens-page:not(.phone) .screens-grid { gap: 12px; }
/* Wide enough for a 28-character route after the dot, in the footer's 10.5px mono with room to spare: Linux's
fonts set it at about 183px. Five cards fit beside the tree at 1440px. */
.screens-page:not(.phone) .screens-cell { width: 216px; }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card {
overflow: hidden;
gap: 0;
border: 1px solid var(--border-subtle);
border-radius: 12px;
background: var(--surface);
transition: border-color 120ms ease, box-shadow 120ms ease;
}
.screens-page:not(.phone) .screens-cell .screen-screenshot-card:has(.screen-screenshot-target:hover) { border-color: color-mix(in srgb, var(--accent) 55%, var(--border-subtle)); }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card.selected { border-color: var(--accent); box-shadow: 0 0 0 1px var(--accent); }
/* The status is laid out against the card, not the screenshot, so it can sit in the footer. */
.screens-page:not(.phone) .screens-cell :is(.screen-screenshot-slot, .diff-frame) { position: static; }
.screens-page:not(.phone) .screens-cell .screen-screenshot-slot { order: 1; height: 236px; flex: none; padding: 12px 0; background: var(--element); }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card.selected .screen-screenshot-slot { background: var(--accent-soft); }
.screens-page:not(.phone) .screens-cell .screen-node-image img,
.screens-page:not(.phone) .screens-cell .screen-node-image > .image-placeholder,
.screens-page:not(.phone) .screens-cell .screen-screenshot-card .diff-frame .screen-node-image img,
.screens-page:not(.phone) .screens-cell .screen-screenshot-card .diff-frame .screen-node-image > .image-placeholder {
border-color: transparent;
border-radius: 8px;
box-shadow: 0 1px 3px rgb(0 0 0 / 0.14);
}
/* The image box hugs the screenshot, so its corners and shadow are the screenshot's and no box shows around it. */
/* The screenshot fits the well both ways at its own proportions (styles.css's max-width and max-height), so a
landscape capture is framed as itself, not letterboxed inside a portrait-sized box. */
.screens-page:not(.phone) .screens-cell .screen-node-image img { width: auto; height: auto; background: transparent; }
/* No screenshot: the well has a size here, so the placeholder fits it the way styles.css fits it to a Map slot,
at the screenshot's proportions, rather than by the cell's width as a phone's cell does (phone.css). */
.screens-page:not(.phone) .screens-cell .screen-node-image:has(> .image-placeholder) { container-type: size; }
.screens-page:not(.phone) .screens-cell .screen-node-image > .image-placeholder {
width: min(
100cqw - 2 * var(--frame-border),
(100cqh - 2 * var(--frame-border)) * var(--screenshot-width) / var(--screenshot-height),
var(--screenshot-width) * 1px
);
height: min(
100cqh - 2 * var(--frame-border),
(100cqw - 2 * var(--frame-border)) * var(--screenshot-height) / var(--screenshot-width),
var(--screenshot-height) * 1px
);
aspect-ratio: auto;
}
/* A selected card's button is pressed, and a focused pressed button brightens (styles.css). Here that would wash out
the screenshot and, as a filter, become the box the status is placed in, lifting it into the well. Keyboard focus
rings the card instead. */
.screens-page:not(.phone) .screens-cell .screen-screenshot-target:focus-visible { filter: none; outline: 0; }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card:has(.screen-screenshot-target:focus-visible) {
box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 42%, transparent);
}
.screens-page:not(.phone) .screens-cell .screen-screenshot-card.selected:has(.screen-screenshot-target:focus-visible) {
box-shadow: 0 0 0 1px var(--accent), 0 0 0 4px color-mix(in srgb, var(--accent) 32%, transparent);
}
.screens-page:not(.phone) .screens-cell .screen-node-heading { order: 2; min-height: 0; padding: 10px 6px 10px 8px; }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card:has(.diff-label) .screen-node-heading { padding-left: 20px; }
.screens-page:not(.phone) .screens-cell .screen-node-title { font-size: 10.5px; line-height: 14px; }
.screens-page:not(.phone) .screens-cell .screen-screenshot-card.selected .screen-node-title { color: var(--accent-strong); font-weight: 600; }
/* The status is the tree's dot before the route, in the status colour (a square for accessibility only); the word
stays in the label's accessible name. */
.screens-page:not(.phone) .screens-cell .screen-screenshot-card .diff-label {
top: auto;
bottom: 13.5px;
left: 8px;
width: 7px;
height: 7px;
overflow: hidden;
padding: 0;
border-radius: 50%;
color: transparent;
background: var(--diff);
box-shadow: none;
font-size: 0;
transform: none;
}
.screens-page:not(.phone) .screens-cell .diff-accessibility-only .diff-label { border-radius: 2px; }
.screens-page:not(.phone) .screens-cell :is(.screens-cell-via, .screens-cell-elsewhere) { padding-inline: 2px; }
/* ── Phone ── */
/* The space under the top bar is a block, not padding: both engines inset a sticky child's rest
position by the scroll container's padding, which pushed the section bar a bar's height too low. */
+18 -142
View File
@@ -5,11 +5,9 @@ import { primaryScreenshotForScreen, screenshotSize } from "../../utils/screen-i
import { diffClass, type BuildDiff, type DiffStatus } from "../../utils/build-diff";
import { focusStatusOf, isCapturedChange } from "../../utils/changed-screens";
import { displayPathForScreen, screenLabel } from "../../utils/screen-path";
import { screenTree, treeIndex, treeNodeKey, treeScreenOrder, type ScreenTree, type ScreenTreeNode } from "../../utils/screen-tree";
import { screenTree, treeIndex, treeNodeKey, type ScreenTree, type ScreenTreeNode } from "../../utils/screen-tree";
import type { Appearance } from "../../utils/appearance";
import type { FocusRequest, FocusStatus } from "../../utils/navigation";
import { shortcutsLive } from "../../utils/shortcuts";
import { HOLD_INITIAL_DELAY_MS, holdIntervalMs } from "../../utils/key-hold";
import { ScreenScreenshotCard } from "../canvas/screen-screenshot-card";
import { useCanvasVisibleFrame } from "../canvas/visible-frame-provider";
import { PhoneSheet } from "../phone/phone-chrome";
@@ -77,26 +75,6 @@ function cardId(id: string): string {
return `screens-card-${id.replace(/[^A-Za-z0-9_-]/g, "_")}`;
}
/**
* The card in the row above or below a screen's, nearest it across: read from where the cards sit, so it follows the
* grid however many columns the page has room for. A short last row still takes ↓ from the row above it.
*/
function cardInNextRow(from: string, ids: readonly string[], down: boolean): string | undefined {
const box = (id: string) => document.getElementById(cardId(id))?.getBoundingClientRect();
const here = box(from);
if (!here) return undefined;
const centre = (rect: DOMRect) => rect.left + rect.width / 2;
const rows = ids.flatMap(id => {
const rect = box(id);
return rect && (down ? rect.top >= here.bottom - 1 : rect.bottom <= here.top + 1) ? [{ id, rect }] : [];
});
if (!rows.length) return undefined;
const nearestTop = down ? Math.min(...rows.map(row => row.rect.top)) : Math.max(...rows.map(row => row.rect.top));
const row = rows.filter(candidate => Math.abs(candidate.rect.top - nearestTop) < 1);
return row.reduce((best, candidate) =>
Math.abs(centre(candidate.rect) - centre(here)) < Math.abs(centre(best.rect) - centre(here)) ? candidate : best).id;
}
function sectionAnchor(id: string): string {
return `screens-section-${id.replace(/[^A-Za-z0-9_-]/g, "_")}`;
}
@@ -190,7 +168,6 @@ function TreeRows(props: {
<button type="button" style={style}
className={`screens-tree-row${node.tab ? " tab" : ""}${props.visible.has(screen.id) ? "" : " filtered"}`}
aria-current={props.selectedScreenId === screen.id ? "true" : undefined}
data-screen-id={screen.id}
aria-expanded={key ? open : undefined}
data-tree-key={key}
onClick={() => props.onSelect(screen.id)}>
@@ -225,8 +202,8 @@ function Legend(props: { others: Appearance[] }) {
}
/**
* Screens as a page that scrolls. On desktop, one grid of every screen in the order of the tree beside it; on a
* phone, a section per route folder (or per tab, when there are no route files), with the tree behind a Tree button.
* Screens as a page that scrolls: a section per route folder (or per tab, when there are no route
* files), with the tree of them beside it on desktop and behind a Tree button on a phone.
*/
export function ScreensView(props: ScreensViewProps) {
const tree: ScreenTree = useMemo(
@@ -245,9 +222,6 @@ export function ScreensView(props: ScreensViewProps) {
const sections = tree.sections
.map(section => ({ ...section, screenIds: section.screenIds.filter(id => shown.has(id)) }))
.filter(section => section.screenIds.length > 0);
// The desktop grid reads in the tree's order, not the sections' (screen-tree.ts).
const treeOrder = useMemo(() => treeScreenOrder(tree), [tree]);
const order = props.phone ? sections.flatMap(section => section.screenIds) : treeOrder.filter(id => shown.has(id));
const others = [...new Set([...(props.changedElsewhere?.values() ?? [])].flat())];
// Folding. All keeps the reader's folds and remembers them per report. Changed folds separately, starting
@@ -347,118 +321,12 @@ export function ScreensView(props: ScreensViewProps) {
requestAnimationFrame(() => document.getElementById(cardId(id))?.scrollIntoView({ block: "center", behavior: "smooth" }));
};
// On desktop the arrow keys move through the cards: ← and → in their order on the page (`order`), as the arrows step
// through screens in Compare, and ↑ and ↓ to the card above or below, by where the cards sit, so they follow the grid
// at any width. A step picks the screen as the tree does, leaving the Inspector as it is, and focus follows it; with
// nothing picked, → and ↓ start at the first card, and a pick that Changed hides steps from where it sits in the tree.
// The tree's rows keep their arrow keys, and so do the Inspector's controls. Phones are left as they were.
// Held, an arrow keeps stepping as Compare's do (key-hold.ts). Return opens the picked screen in the Inspector, as a
// click on its card does; on the card itself the button already does.
const orderRef = useRef(order);
orderRef.current = order;
const treeOrderRef = useRef(treeOrder);
treeOrderRef.current = treeOrder;
const selectedRef = useRef(selected);
selectedRef.current = selected;
const pickRef = useRef(props.onPickScreen ?? props.onSelectScreen);
pickRef.current = props.onPickScreen ?? props.onSelectScreen;
const openRef = useRef(props.onSelectScreen);
openRef.current = props.onSelectScreen;
useEffect(() => {
if (props.phone) return;
/** The card an arrow moves to from `from` (the pick, or the last card a hold stepped to). */
const next = (code: string, from: string | undefined): string | undefined => {
const ids = orderRef.current;
const vertical = code === "ArrowUp" || code === "ArrowDown";
const forward = code === "ArrowRight" || code === "ArrowDown";
if (from && ids.includes(from)) return vertical ? cardInNextRow(from, ids, forward) : ids[ids.indexOf(from) + (forward ? 1 : -1)];
if (from && treeOrderRef.current.includes(from)) {
// Picked, but hidden by Changed: the nearest shown card past it in the tree's order.
const shownIds = new Set(ids);
const all = treeOrderRef.current;
const at = all.indexOf(from);
return (forward ? all.slice(at + 1) : all.slice(0, at).reverse()).find(candidate => shownIds.has(candidate));
}
return forward ? ids[0] : ids[ids.length - 1];
};
const go = (id: string) => {
pickRef.current(id);
requestAnimationFrame(() => document.getElementById(cardId(id))?.querySelector<HTMLElement>(".screen-screenshot-target")?.focus({ preventScroll: true }));
};
let hold: { code: string; at: string; timer: ReturnType<typeof setTimeout> } | undefined;
const endHold = () => {
if (hold) clearTimeout(hold.timer);
hold = undefined;
};
const beginHold = (code: string, at: string) => {
endHold();
let step = 1;
const tick = () => {
const id = hold && next(code, hold.at);
if (!hold || !id) { endHold(); return; }
go(id);
hold = { code, at: id, timer: setTimeout(tick, holdIntervalMs(step)) };
step += 1;
};
hold = { code, at, timer: setTimeout(tick, HOLD_INITIAL_DELAY_MS) };
};
const onKeyDown = (event: globalThis.KeyboardEvent) => {
const arrow = ["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(event.code);
if (!arrow && event.key !== "Enter") return;
// The browser's own repeat of a held arrow would scroll the page under the hold.
if (event.repeat && hold?.code === event.code) { event.preventDefault(); return; }
if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey || event.defaultPrevented || !shortcutsLive(event)) return;
const target = event.target instanceof Element ? event.target : null;
if (!arrow) {
// Return on a button or a link presses it; elsewhere on the page it opens the pick.
const selectedId = selectedRef.current;
if (target?.closest("button, a, [role=\"button\"]") || !target?.closest("body") || !selectedId || !orderRef.current.includes(selectedId)) return;
if (target !== document.body && !target.closest(".screens-page")) return;
event.preventDefault();
openRef.current(selectedId);
return;
}
// The page, or the bottom toolbar that Screens was just opened from; its buttons have no arrow keys of their own.
const onPage = !target || target === document.body || target.closest(".screens-page, .canvas-toolbar") !== null;
if (!onPage || target?.closest(".screens-tree-list")) return;
const id = next(event.code, selectedRef.current);
if (!id) return;
event.preventDefault();
go(id);
beginHold(event.code, id);
};
const onKeyUp = (event: globalThis.KeyboardEvent) => {
if (hold && event.code === hold.code) endHold();
};
window.addEventListener("keydown", onKeyDown);
window.addEventListener("keyup", onKeyUp);
window.addEventListener("blur", endHold);
return () => {
endHold();
window.removeEventListener("keydown", onKeyDown);
window.removeEventListener("keyup", onKeyUp);
window.removeEventListener("blur", endHold);
};
}, [props.phone]);
// The Inspector floats over the right edge; the page keeps its content clear of it.
const { visibleFrame } = useCanvasVisibleFrame();
const style = !props.phone && visibleFrame
? ({ "--screens-right-inset": `calc(100% - ${visibleFrame.x + visibleFrame.width}px)` } as CSSProperties)
: undefined;
const cell = (id: string) => {
const screen = props.index.screens.get(id);
return screen ? (
<ScreenCell key={id} screen={screen} index={props.index} diff={props.diff}
elsewhere={isChanged(props.diff, id) ? undefined : props.changedElsewhere?.get(id)}
via={tree.via.get(id)}
selected={props.selectedScreenId === id}
dimmed={Boolean(props.focus?.length) && !props.focus!.some((state) => state === focusStatusOf(props.diff?.screens.get(id)))}
onSelect={() => props.onSelectScreen(id)} />
) : null;
};
const treeRows = (
<ul className="screens-tree-list" onKeyDown={onTreeKey}>
<TreeRows nodes={tree.tree} depth={0} index={props.index} diff={props.diff} elsewhere={props.changedElsewhere}
@@ -510,20 +378,28 @@ export function ScreensView(props: ScreensViewProps) {
</aside>
)}
<div className="screens-sections">
{props.phone ? sections.map(section => (
{sections.map(section => (
<section key={section.id} id={sectionAnchor(section.id)} className="screens-section" aria-label={section.name ?? section.title}>
<header className="screens-section-head">
<h2>{section.name ?? section.title}</h2>
{section.path ? <span className="path">{breakAfterSlashes(section.title)}</span>
: section.subtitle ? <span>{section.subtitle}</span> : null}
</header>
<div className="screens-grid">{section.screenIds.map(cell)}</div>
<div className="screens-grid">
{section.screenIds.map(id => {
const screen = props.index.screens.get(id);
return screen ? (
<ScreenCell key={id} screen={screen} index={props.index} diff={props.diff}
elsewhere={isChanged(props.diff, id) ? undefined : props.changedElsewhere?.get(id)}
via={tree.via.get(id)}
selected={props.selectedScreenId === id}
dimmed={Boolean(props.focus?.length) && !props.focus!.some((state) => state === focusStatusOf(props.diff?.screens.get(id)))}
onSelect={() => props.onSelectScreen(id)} />
) : null;
})}
</div>
</section>
)) : (
// On desktop the tree beside the page already shows the folders, so every screen sits in one evenly
// spaced grid in the tree's order, without headings between them.
<div className="screens-grid">{order.map(cell)}</div>
)}
))}
</div>
</div>
+2 -2
View File
@@ -4,8 +4,8 @@
* or a spinner accelerates. The browser's own key repeat is ignored (its rate is a fixed OS setting),
* so the hold is timed here and ends on key up, blur, or the end of the list.
*/
export const HOLD_INITIAL_DELAY_MS = 250;
export const HOLD_FIRST_INTERVAL_MS = 200;
export const HOLD_INITIAL_DELAY_MS = 400;
export const HOLD_FIRST_INTERVAL_MS = 300;
export const HOLD_FLOOR_INTERVAL_MS = 70;
const HOLD_DECAY = 0.8;
-16
View File
@@ -228,22 +228,6 @@ export type ScreenTreeIndex = {
parents: Map<string, string>;
};
/**
* Every screen in the order the tree lists it: depth first, so a subfolder's screens follow its parent folder's own,
* where sections list folders in the order they were found. A screen the tree leaves out comes last.
*/
export function treeScreenOrder(tree: ScreenTree): string[] {
const ids: string[] = [];
const walk = (nodes: readonly ScreenTreeNode[]) => {
for (const node of nodes) {
if (node.kind === "screen") ids.push(node.screenId);
walk(node.children);
}
};
walk(tree.tree);
return [...new Set([...ids, ...tree.sections.flatMap(section => section.screenIds)])];
}
export function treeIndex(tree: readonly ScreenTreeNode[]): ScreenTreeIndex {
const index: ScreenTreeIndex = { keys: [], screensUnder: new Map(), ancestors: new Map(), parents: new Map() };
const walk = (nodes: readonly ScreenTreeNode[], above: string[]): string[] => nodes.flatMap((node) => {
+3 -23
View File
@@ -7,8 +7,6 @@ export type Shortcut = {
code: string;
/** ⌘ on Apple keyboards, Ctrl everywhere else. */
mod?: boolean;
/** The Control key itself on every keyboard, for chords whose ⌘ form the browser keeps (⌘1–⌘9 switch tabs). */
ctrl?: boolean;
/** ⌥ on Apple keyboards, Alt everywhere else. */
alt?: boolean;
shift?: boolean;
@@ -19,12 +17,6 @@ export type Shortcut = {
const APPLE = typeof navigator !== "undefined"
&& /Mac|iPhone|iPad|iPod/.test(navigator.platform || navigator.userAgent);
/**
* Whether Ctrl+1–3 reach the page. On Apple keyboards ⌃ is free (the browser's tab keys are ⌘1–9); elsewhere the
* browser keeps Ctrl+1–8 for its tabs, so those keys are neither handled nor printed there.
*/
export const CANVAS_NUMBER_KEYS = APPLE;
function mod(code: string, key: string): Shortcut {
return { code, key, mod: true };
}
@@ -33,10 +25,6 @@ function modShift(code: string, key: string): Shortcut {
return { code, key, mod: true, shift: true };
}
function ctrl(code: string, key: string): Shortcut {
return { code, key, ctrl: true };
}
function shift(code: string, key: string): Shortcut {
return { code, key, shift: true };
}
@@ -80,12 +68,6 @@ export const SHORTCUTS = {
screens: plain("KeyS", "S"),
compare: plain("KeyC", "C"),
},
/** The canvases by their place in the toolbar, as tabs are numbered elsewhere. Apple keyboards only (CANVAS_NUMBER_KEYS). */
canvasByNumber: {
map: ctrl("Digit1", "1"),
screens: ctrl("Digit2", "2"),
compare: ctrl("Digit3", "3"),
},
/** Compare only. The arrows walk changed screens; J and K walk the changed areas of one. */
compare: {
previousScreen: plain("ArrowLeft", "←"),
@@ -110,10 +92,10 @@ export const SHORTCUTS = {
/** The hint, in the idiom of the keyboard reading it: Apple's ⌥⇧⌘ order, or Ctrl+Alt+Shift. */
export function formatShortcut(shortcut: Shortcut, apple = APPLE): string {
if (apple) {
return `${shortcut.ctrl ? "⌃" : ""}${shortcut.alt ? "⌥" : ""}${shortcut.shift ? "⇧" : ""}${shortcut.mod ? "⌘" : ""}${shortcut.key}`;
return `${shortcut.alt ? "⌥" : ""}${shortcut.shift ? "⇧" : ""}${shortcut.mod ? "⌘" : ""}${shortcut.key}`;
}
const parts: string[] = [];
if (shortcut.mod || shortcut.ctrl) parts.push("Ctrl");
if (shortcut.mod) parts.push("Ctrl");
if (shortcut.alt) parts.push("Alt");
if (shortcut.shift) parts.push("Shift");
parts.push(shortcut.key);
@@ -122,9 +104,7 @@ export function formatShortcut(shortcut: Shortcut, apple = APPLE): string {
export function matchesShortcut(event: KeyboardEvent, shortcut: Shortcut): boolean {
if (event.code !== shortcut.code) return false;
if (shortcut.ctrl) {
if (!event.ctrlKey || event.metaKey) return false;
} else if ((event.metaKey || event.ctrlKey) !== Boolean(shortcut.mod)) return false;
if ((event.metaKey || event.ctrlKey) !== Boolean(shortcut.mod)) return false;
if (event.shiftKey !== Boolean(shortcut.shift)) return false;
return event.altKey === Boolean(shortcut.alt);
}