Compare commits

...
Author SHA1 Message Date
Brent Vatne 0a4c5690d1 Merge remote-tracking branch 'origin/main' into @brent/map-selection-ring 2026-10-18 21:55:48 -07:00
Brent Vatne 458003e9e5 Viewer: Return after the Map's arrow keys opens the screen they reached
A click left the keyboard focus on the clicked screen's button, so after walking the Map with the arrow keys Return pressed that button and opened the screen clicked before. A walk now lets go of a card's focus, and Return elsewhere on the Map opens the selection in the Inspector.
2026-10-18 21:55:43 -07:00
Brent Vatne 5f12800908 Viewer: ring the selected Map screen instead of fading the rest, a grey ring on hover and no tooltip
Selecting a screen on the Map no longer fades every other card. The selected card takes an accent ring outside its status border, past a gap in the canvas colour, with a soft lift and an accent route; its transitions stay accent and a little heavier while every other transition quiets to a hairline. Hover draws the same ring in grey and darkens the hovered card's transitions to grey. The Map's cards drop the Open in Inspector tooltip; Screens keeps it. Below a readable zoom the ring's unit grows so it stays visible.
2026-10-18 21:55:43 -07:00
7 changed files with 291 additions and 222 deletions

No files matched your search

@@ -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");
+184 -149
View File
@@ -80,136 +80,121 @@ async function expectAutoHideScrollbar(
await expect(scrollbar).toHaveCSS("opacity", "0");
}
async function expectMapScreenSelectionDimming(
page: Page,
options: { hoverTargetCount?: number } = {},
) {
const screens = page.locator(
".map-canvas .react-flow__node-screen:not(.canvas-node-exit)",
);
const selected = page.locator(
".map-canvas .react-flow__node-screen.selected:not(.canvas-node-exit)",
);
const dimmed = page.locator(
".map-canvas .react-flow__node-screen:not(.selected):not(.canvas-node-exit)",
);
await expect(page.locator(".map-canvas")).toHaveClass(/screen-selection-active/);
await expect(selected).toHaveCount(1);
await expect.poll(async () => dimmed.count()).toBe((await screens.count()) - 1);
expect(await screens.evaluateAll(nodes => nodes.every(node => getComputedStyle(node).opacity === "1"))).toBe(true);
/** The Map's canvas tokens as computed colours, to compare with what a ring or an edge draws. */
async function mapCanvasColors(page: Page) {
return page.locator(".map-canvas").evaluate((canvas) => {
const resolve = (token: string) => {
const probe = document.createElement("span");
probe.style.color = `var(${token})`;
canvas.append(probe);
const color = getComputedStyle(probe).color;
probe.remove();
return color;
};
return {
accent: resolve("--accent"),
accentStrong: resolve("--accent-strong"),
hoverRing: resolve("--hover-ring"),
quiet: resolve("--border-subtle"),
hoverEdge: resolve("--tertiary"),
};
});
}
await expect.poll(async () => {
const [selectedOpacity, dimmedOpacity] = await Promise.all([
selected.locator(":scope > .canvas-active-frame").evaluate((node) => Number.parseFloat(getComputedStyle(node).opacity)),
dimmed.first().locator(":scope > .canvas-active-frame").evaluate((node) => Number.parseFloat(getComputedStyle(node).opacity)),
]);
return dimmedOpacity < selectedOpacity;
}).toBe(true);
/** The screenshot frame's box shadow on a Map card: where its ring is drawn. */
function mapCardRing(node: Locator) {
return node.locator(".screen-node-image :is(img, .image-placeholder)").first()
.evaluate((frame) => getComputedStyle(frame).boxShadow);
}
// Selection focus moves the canvas before hover affordances are exercised. Choose hover
// targets only after that flight settles so a node cannot move underneath the minimap between
// the hit-test below and Playwright's pointer action.
await expect(page.locator(".map-canvas.canvas-focus-animating")).toHaveCount(0);
const hoverableDimmedIndexes = await dimmed.evaluateAll((nodes) => nodes.flatMap((node, index) => {
const bounds = node.getBoundingClientRect();
const centerTarget = document.elementFromPoint(
bounds.left + bounds.width / 2,
bounds.top + bounds.height / 2,
);
const nodeId = node.getAttribute("data-id");
const hasDirectEdge = nodeId !== null && [...document.querySelectorAll(".react-flow__edge")]
.some((edge) => {
const label = edge.getAttribute("aria-label") ?? "";
return label.startsWith(`Edge from ${nodeId} to `) || label.endsWith(` to ${nodeId}`);
});
return centerTarget !== null && node.contains(centerTarget) && hasDirectEdge ? [index] : [];
/** Each Map edge's id, ends and drawn stroke. */
function mapEdgeStrokes(page: Page) {
return page.locator(".map-canvas .react-flow__edge").evaluateAll((edges) => edges.map((edge) => {
const match = /^Edge from (.+) to (.+)$/.exec(edge.getAttribute("aria-label") ?? "");
const path = getComputedStyle(edge.querySelector(".transition-edge-path")!);
return {
id: edge.getAttribute("data-id") ?? "",
from: match?.[1] ?? "",
to: match?.[2] ?? "",
stroke: path.stroke,
strokeWidth: Number.parseFloat(path.strokeWidth),
};
}));
const hoverTargetCount = options.hoverTargetCount ?? 1;
expect(hoverableDimmedIndexes.length).toBeGreaterThanOrEqual(hoverTargetCount);
// A card fades through its frame's --map-card-opacity (the node itself stays opaque over the
// connectors). The property is not animated, so it reads what hover asks for at once.
const cardOpacities = () => screens.evaluateAll((nodes) => Object.fromEntries(nodes.map((node) => [
node.getAttribute("data-id") ?? "",
getComputedStyle(node.querySelector(":scope > .canvas-active-frame")!).getPropertyValue("--map-card-opacity").trim(),
])));
const restingOpacities = await cardOpacities();
let lastHoverTarget = dimmed.nth(hoverableDimmedIndexes[0]!);
}
for (const index of hoverableDimmedIndexes.slice(0, hoverTargetCount)) {
const hoverTarget = dimmed.nth(index);
const hoverTargetId = await hoverTarget.getAttribute("data-id");
expect(hoverTargetId).not.toBeNull();
await hoverTarget.hover();
await expect.poll(() => hoverTarget.locator(":scope > .canvas-active-frame").evaluate(
(node) => Number.parseFloat(getComputedStyle(node).opacity),
)).toBe(1);
await expect(hoverTarget).toHaveCSS("filter", "none");
const hoverSubject = page.locator(
".map-canvas .react-flow__node-screen.graph-node-hover-subject",
);
await expect(hoverSubject).toHaveCount(1);
await expect(hoverSubject).toHaveAttribute("data-id", hoverTargetId!);
const allEdges = page.locator(".map-canvas .react-flow__edge");
const directEdgeCount = await allEdges.evaluateAll((edges, nodeId) => edges.filter((edge) => {
const label = edge.getAttribute("aria-label") ?? "";
return label.startsWith(`Edge from ${nodeId} to `) || label.endsWith(` to ${nodeId}`);
}).length, hoverTargetId!);
expect(directEdgeCount).toBeGreaterThan(0);
// The hovered screen and every screen it shares an edge with are marked related; nothing on
// the map recedes while hovering, so the only changes are the subject ring, the incident
// edges and the neighbours' frames.
const neighbourIds = await allEdges.evaluateAll((edges, nodeId) => {
const ids = new Set<string>([nodeId]);
for (const edge of edges) {
const match = /^Edge from (.+) to (.+)$/.exec(edge.getAttribute("aria-label") ?? "");
if (!match) continue;
if (match[1] === nodeId) ids.add(match[2]!);
if (match[2] === nodeId) ids.add(match[1]!);
}
return [...ids].sort();
}, hoverTargetId!);
const brightNodes = page.locator(
".map-canvas .react-flow__node-screen.graph-node-hover-related",
);
await expect.poll(() => brightNodes.evaluateAll((nodes) => (
nodes.map((node) => node.getAttribute("data-id") ?? "").sort()
))).toEqual(neighbourIds);
const unrelated = page.locator(
".map-canvas .react-flow__node-screen:not(.graph-node-hover-related):not(.canvas-node-exit)",
);
const unrelatedIds = await unrelated.evaluateAll((nodes) => nodes.map((node) => node.getAttribute("data-id") ?? ""));
expect(unrelatedIds.length).toBeGreaterThan(0);
const hoverOpacities = await cardOpacities();
expect(unrelatedIds.map((id) => hoverOpacities[id])).toEqual(unrelatedIds.map((id) => restingOpacities[id]));
expect(await unrelated.evaluateAll((nodes) => nodes.every((node) => getComputedStyle(node).filter === "none"))).toBe(true);
await expect(page.locator(".map-canvas .screen-open-hint:visible")).toHaveCount(0);
const activeEdges = page.locator(
".map-canvas .react-flow__edge.graph-edge-hover-related",
);
await expect(activeEdges).toHaveCount(directEdgeCount);
const activeEdgeLabels = await activeEdges.evaluateAll((edges) => (
edges.map((edge) => edge.getAttribute("aria-label") ?? "")
/**
* A selected Map screen is ringed in the accent, its route turns accent and its transitions stay
* accent while every other transition quiets to a hairline. No card fades. Hovering another card
* rings it in grey beside the selection, with no tooltip, and darkens its own transitions;
* hovering the selected card keeps its accent ring.
*/
async function expectMapSelectionRing(page: Page) {
const screens = page.locator(".map-canvas .react-flow__node-screen:not(.canvas-node-exit)");
const selected = page.locator(".map-canvas .react-flow__node-screen.selected:not(.canvas-node-exit)");
await expect(selected).toHaveCount(1);
const selectedId = (await selected.getAttribute("data-id"))!;
const colors = await mapCanvasColors(page);
await expect.poll(() => mapCardRing(selected)).toContain(colors.accent);
await expect(selected.locator(".screen-node-title")).toHaveCSS("color", colors.accentStrong);
// Nothing fades: every card and its frame stay at full strength.
await expect.poll(() => screens.evaluateAll((nodes) => nodes.every((node) => (
getComputedStyle(node).opacity === "1"
&& getComputedStyle(node.querySelector(":scope > .canvas-active-frame")!).opacity === "1"
&& ["", "1"].includes(getComputedStyle(node.querySelector(":scope > .canvas-active-frame")!).getPropertyValue("--map-card-opacity").trim())
)))).toBe(true);
const unselected = page.locator(".map-canvas .react-flow__node-screen:not(.selected):not(.canvas-node-exit)");
expect(await unselected.evaluateAll((nodes, accent) => nodes.every((node) => (
!getComputedStyle(node.querySelector(".screen-node-image :is(img, .image-placeholder)")!).boxShadow.includes(accent)
)), colors.accent)).toBe(true);
// The selection's transitions are accent and a little heavier; every other one is a hairline.
const edges = await mapEdgeStrokes(page);
const incident = edges.filter((edge) => edge.from === selectedId || edge.to === selectedId);
const others = edges.filter((edge) => edge.from !== selectedId && edge.to !== selectedId);
expect(incident.length).toBeGreaterThan(0);
expect(others.length).toBeGreaterThan(0);
expect(incident.every((edge) => edge.stroke === colors.accent && edge.strokeWidth === 2.5)).toBe(true);
expect(others.every((edge) => edge.stroke === colors.quiet && edge.strokeWidth === 1)).toBe(true);
await expect(page.locator(".map-canvas .react-flow__edge.graph-edge-quiet")).toHaveCount(others.length);
// Hover a card that shares no edge with the selection but has edges of its own.
await expect(page.locator(".map-canvas.canvas-focus-animating")).toHaveCount(0);
const neighbours = new Set(incident.flatMap((edge) => [edge.from, edge.to]));
const hoverId = await unselected.evaluateAll((nodes, excluded) => nodes.find((node) => {
const id = node.getAttribute("data-id") ?? "";
const target = node.querySelector(".screen-screenshot-target")!.getBoundingClientRect();
const hit = document.elementFromPoint(target.left + target.width / 2, target.top + target.height / 3);
const linked = [...document.querySelectorAll(".map-canvas .react-flow__edge")].some((edge) => (
(edge.getAttribute("aria-label") ?? "").split(/ (?:from|to) /).slice(1).includes(id)
));
expect(activeEdgeLabels.every((label) => (
label.startsWith(`Edge from ${hoverTargetId} to `)
|| label.endsWith(` to ${hoverTargetId}`)
))).toBe(true);
lastHoverTarget = hoverTarget;
if (index !== hoverableDimmedIndexes.slice(0, hoverTargetCount).at(-1)) {
await page.mouse.move(1, 1);
await page.waitForTimeout(160);
}
return !excluded.includes(id) && linked && hit !== null && node.contains(hit);
})?.getAttribute("data-id"), [...neighbours]);
expect(hoverId).toBeTruthy();
const hovered = page.locator(`.map-canvas .react-flow__node-screen[data-id="${hoverId}"]`);
const target = hovered.locator(".screen-screenshot-target");
const box = (await target.boundingBox())!;
await target.hover({ position: { x: box.width / 2, y: box.height / 3 } });
await expect(hovered).toHaveClass(/graph-node-hover-subject/);
await expect.poll(() => mapCardRing(hovered)).toContain(colors.hoverRing);
await expect.poll(() => mapCardRing(selected)).toContain(colors.accent);
// Past the tooltip delay, nothing says Open in Inspector.
await page.waitForTimeout(600);
await expect(page.locator(".tooltip")).toHaveCount(0);
// The hovered card's transitions darken to grey; the selection's stay accent; the rest stay quiet.
const hovering = await mapEdgeStrokes(page);
for (const edge of hovering) {
if (edge.from === selectedId || edge.to === selectedId) expect(edge.stroke, edge.id).toBe(colors.accent);
else if (edge.from === hoverId || edge.to === hoverId) expect(edge.stroke, edge.id).toBe(colors.hoverEdge);
else expect(edge.stroke, edge.id).toBe(colors.quiet);
}
// Hovering the selected card keeps its accent ring.
const selectedTarget = selected.locator(".screen-screenshot-target");
const selectedBox = (await selectedTarget.boundingBox())!;
await selectedTarget.hover({ position: { x: selectedBox.width / 2, y: selectedBox.height / 3 } });
await expect(selected).toHaveClass(/graph-node-hover-subject/);
await expect.poll(() => mapCardRing(selected)).toContain(colors.accent);
expect(await mapCardRing(selected)).not.toContain(colors.hoverRing);
await expect.poll(() => mapCardRing(hovered)).not.toContain(colors.hoverRing);
await page.mouse.move(1, 1);
await expect.poll(async () => {
const [selectedOpacity, dimmedOpacity] = await Promise.all([
selected.locator(":scope > .canvas-active-frame").evaluate((node) => Number.parseFloat(getComputedStyle(node).opacity)),
lastHoverTarget.locator(":scope > .canvas-active-frame").evaluate((node) => Number.parseFloat(getComputedStyle(node).opacity)),
]);
return dimmedOpacity < selectedOpacity;
}).toBe(true);
}
/** The camera chrome's theme button steps Auto → Dark → Light; press it until the page shows the option. */
@@ -1529,6 +1514,59 @@ test("Esc closes the Inspector first, then deselects; arrows and hjkl walk the m
await expect(selected).toHaveAttribute("data-id", child!);
});
test("Return after the arrow keys opens the screen they reached, not the one clicked before, on the Map and on Screens", async ({ page }) => {
await serveSyntheticWorkspace(page);
const inspector = page.getByRole("complementary", { name: "Inspector panel" });
const accent = await page.evaluate(() => {
const probe = document.createElement("span");
probe.style.color = "#0588f0";
document.body.append(probe);
const color = getComputedStyle(probe).color;
probe.remove();
return color;
});
// Map: the click leaves the keyboard focus on the first screen's button; Return must not press it.
await page.goto("/map?screen=area-0-screen-1");
const selected = page.locator(".map-canvas .react-flow__node-screen.selected");
await expect(selected).toHaveAttribute("data-id", "area-0-screen-1");
await expectMapCameraAtRest(page);
await selected.locator(".screen-screenshot-target").click();
await expect(inspector).toBeVisible();
await page.keyboard.press("Escape");
await expect(inspector).toBeHidden();
await page.keyboard.press("ArrowDown");
await expect(selected).not.toHaveAttribute("data-id", "area-0-screen-1");
const reached = (await selected.getAttribute("data-id"))!;
// The ring went with the selection.
const ring = (id: string) => page.locator(`.map-canvas .react-flow__node-screen[data-id="${id}"] .screen-node-image img`)
.evaluate((image) => getComputedStyle(image).boxShadow);
await expect.poll(() => ring(reached)).toContain(accent);
await expect.poll(() => ring("area-0-screen-1")).not.toContain(accent);
const reachedPath = (await selected.locator(".screen-node-title").textContent())!;
await page.keyboard.press("Enter");
await expect(inspector).toBeVisible();
await expect(selected).toHaveAttribute("data-id", reached);
await expect(page).toHaveURL(new RegExp(`screen=${reached}`));
await expect(inspector).toContainText(reachedPath);
// Screens: the same walk, from a clicked card.
await chooseCanvasView(page, "Screens");
const grid = page.getByRole("main", { name: "Screens" });
await grid.getByRole("button", { name: /^All/ }).click();
const ids = await grid.locator(".screens-grid .screens-cell")
.evaluateAll((elements) => elements.map((element) => element.getAttribute("data-screen-id")!));
await grid.locator(`.screens-cell[data-screen-id="${ids[0]}"] .screen-screenshot-target`).click();
await expect(inspector).toBeVisible();
await page.keyboard.press("Escape");
await expect(inspector).toBeHidden();
await page.keyboard.press("ArrowRight");
await expect(grid.locator(`.screens-cell[data-screen-id="${ids[1]}"] .screen-screenshot-card`)).toHaveClass(/selected/);
await page.keyboard.press("Enter");
await expect(inspector).toBeVisible();
await expect(page).toHaveURL(new RegExp(`screen=${ids[1]}`));
});
test("a held key stops when Esc, another key or a dialog takes the keyboard; a menu keeps its own arrows", async ({ page }) => {
await page.goto("/map");
const selected = page.locator(".map-canvas .react-flow__node-screen.selected");
@@ -1955,7 +1993,7 @@ test("fits the visible Map screenshot frame to the capture's intrinsic ratio", a
const selected = page.locator(".map-canvas .react-flow__node-screen.selected");
const image = selected.locator(".screen-node-image img");
await expect(image).toBeVisible();
await expectMapScreenSelectionDimming(page);
await expectMapSelectionRing(page);
const pathStyle = await selected.locator(".screen-node-title").evaluate((element) => {
const style = getComputedStyle(element);
const bounds = element.getBoundingClientRect();
@@ -2042,13 +2080,18 @@ async function hoverableMapScreen(candidates: Locator, room = 80) {
return candidates.nth(index);
}
test("hovering a Map screen fades nothing and says Open in Inspector in a tooltip below the card that keeps to it", async ({ page }) => {
test("hovering a Map screen fades nothing, rings it in grey, darkens its transitions and shows no tooltip", async ({ page }) => {
await serveSyntheticWorkspace(page);
await page.goto("/map");
const screens = page.locator(".map-canvas .react-flow__node-screen:not(.canvas-node-exit)");
await expect(screens.first()).toBeVisible();
await expectMapCameraAtRest(page);
const colors = await mapCanvasColors(page);
const resting = await mapCardOpacities(page);
// With nothing selected no transition is quiet: they keep their own colours.
await expect(page.locator(".map-canvas .react-flow__edge.graph-edge-quiet")).toHaveCount(0);
const restingEdges = await mapEdgeStrokes(page);
expect(restingEdges.some((edge) => edge.stroke === colors.quiet)).toBe(false);
// A screen at one end of a secondary transition, which rests a little faded.
const secondaryEnds = await page.locator(".map-canvas .react-flow__edge.graph-edge-secondary").evaluateAll((edges) => (
[...new Set(edges.flatMap((edge) => /^Edge from (.+) to (.+)$/.exec(edge.getAttribute("aria-label") ?? "")?.slice(1) ?? []))]
@@ -2057,42 +2100,34 @@ test("hovering a Map screen fades nothing and says Open in Inspector in a toolti
const node = await hoverableMapScreen(page.locator(
secondaryEnds.map((id) => `.map-canvas .react-flow__node-screen[data-id="${id}"]`).join(", "),
));
const id = (await node.getAttribute("data-id"))!;
const target = node.locator(".screen-screenshot-target");
const heading = node.locator(".screen-node-heading");
// The tooltip says what a click does; no native title tooltip joins it.
// No native title tooltip either; the heading names the screen.
await expect(target).not.toHaveAttribute("title");
// Near the card's top, so the pan below keeps the pointer on it.
const box = (await target.boundingBox())!;
await target.hover({ position: { x: box.width / 2, y: box.height / 4 } });
await expect(page.locator(".connection-canvas-surface.canvas-hovering")).toHaveCount(1);
const tooltip = page.locator(".tooltip", { hasText: "Open in Inspector" });
await expect(tooltip).toBeVisible();
await expect.poll(() => mapCardRing(node)).toContain(colors.hoverRing);
expect(await mapCardRing(node)).not.toContain(colors.accent);
// Past the tooltip delay, nothing covers or labels the card.
await page.waitForTimeout(600);
await expect(page.locator(".tooltip")).toHaveCount(0);
await expect(page.locator(".map-canvas .screen-open-hint:visible")).toHaveCount(0);
const related = await page.locator(".map-canvas .react-flow__node-screen.graph-node-hover-related")
.evaluateAll((nodes) => nodes.map((element) => element.getAttribute("data-id") ?? ""));
const unrelated = Object.keys(resting).filter((id) => !related.includes(id));
const unrelated = Object.keys(resting).filter((other) => !related.includes(other));
expect(unrelated.length).toBeGreaterThan(0);
const hovering = await mapCardOpacities(page);
expect(unrelated.map((id) => hovering[id])).toEqual(unrelated.map((id) => resting[id]));
await expect(page.locator(".map-canvas .screen-open-hint:visible")).toHaveCount(0);
// The transitions into and out of it come fully up, the secondary one too.
expect(unrelated.map((other) => hovering[other])).toEqual(unrelated.map((other) => resting[other]));
// The transitions into and out of it come fully up in a darker grey, the secondary one too; the rest stay as they were.
const incident = page.locator(".map-canvas .react-flow__edge.graph-edge-hover-related");
await expect(incident.and(page.locator(".graph-edge-secondary"))).not.toHaveCount(0);
await expect.poll(() => incident.evaluateAll((edges) => edges.every((edge) => getComputedStyle(edge).opacity === "1"))).toBe(true);
// The route heads a Map card, so the bubble sits below the screenshot, clear of both.
const clearance = async () => {
const [bubble, card, title] = await Promise.all([tooltip.boundingBox(), target.boundingBox(), heading.boundingBox()]);
if (!bubble || !card || !title) return Number.NaN;
const headingOverlap = bubble.y < title.y + title.height && title.y < bubble.y + bubble.height
&& bubble.x < title.x + title.width && title.x < bubble.x + bubble.width;
return headingOverlap ? -1 : bubble.y - (card.y + card.height);
};
expect(await clearance()).toBeGreaterThan(0);
// Panning with the pointer still on the card moves the card by transform; the bubble follows it
// rather than staying behind over the screenshot.
const before = await target.boundingBox();
await page.mouse.wheel(0, 40);
await expect.poll(async () => (await target.boundingBox())!.y).toBeLessThan(before!.y - 10);
await expect.poll(clearance).toBeGreaterThan(0);
const hoverEdges = await mapEdgeStrokes(page);
for (const edge of hoverEdges) {
if (edge.from === id || edge.to === id) expect(edge.stroke, edge.id).toBe(colors.hoverEdge);
else expect(edge.stroke, edge.id).toBe(restingEdges.find((resting) => resting.id === edge.id)!.stroke);
}
});
test("hovering a Map screen the Changes filter muted brings it and its neighbours back up, and nothing else", async ({ page }) => {
@@ -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"
@@ -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.
+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}
+53 -40
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);
@@ -461,6 +460,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 +481,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 +501,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 +676,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 +696,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 +712,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 +726,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 +941,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 +967,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;