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 292 additions and 223 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 expect(sourceHitArea.locator("title")).toHaveText("Source navigation\npush · app/home.tsx");
await page.mouse.move(1320, 30); await page.mouse.move(1320, 30);
const dimmedComparisons = []; 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 => { await page.evaluate(mode => {
const profile = document.querySelector('.react-flow__node[data-id="profile"]'); const profile = document.querySelector('.react-flow__node[data-id="profile"]');
const canvas = document.querySelector(".map-canvas");
profile.classList.toggle("graph-node-muted", mode === "muted"); profile.classList.toggle("graph-node-muted", mode === "muted");
canvas.classList.toggle("screen-selection-active", mode === "selection");
}, presentation); }, presentation);
const dimmedWithArrows = await profileImage.screenshot({ animations: "disabled" }); const dimmedWithArrows = await profileImage.screenshot({ animations: "disabled" });
await page.locator(".map-surface .react-flow__edges").evaluate(node => { node.style.visibility = "hidden"; }); 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(() => { await page.evaluate(() => {
document.querySelector('.react-flow__node[data-id="profile"]').classList.remove("graph-node-muted"); 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(); await page.getByRole("button", { name: "Open Profile", exact: true }).click();
assert.equal(await page.evaluate(() => window.selectedScreen), "profile"); assert.equal(await page.evaluate(() => window.selectedScreen), "profile");
+185 -150
View File
@@ -80,136 +80,121 @@ async function expectAutoHideScrollbar(
await expect(scrollbar).toHaveCSS("opacity", "0"); await expect(scrollbar).toHaveCSS("opacity", "0");
} }
async function expectMapScreenSelectionDimming( /** The Map's canvas tokens as computed colours, to compare with what a ring or an edge draws. */
page: Page, async function mapCanvasColors(page: Page) {
options: { hoverTargetCount?: number } = {}, return page.locator(".map-canvas").evaluate((canvas) => {
) { const resolve = (token: string) => {
const screens = page.locator( const probe = document.createElement("span");
".map-canvas .react-flow__node-screen:not(.canvas-node-exit)", probe.style.color = `var(${token})`;
); canvas.append(probe);
const selected = page.locator( const color = getComputedStyle(probe).color;
".map-canvas .react-flow__node-screen.selected:not(.canvas-node-exit)", probe.remove();
); return color;
const dimmed = page.locator( };
".map-canvas .react-flow__node-screen:not(.selected):not(.canvas-node-exit)", return {
); accent: resolve("--accent"),
await expect(page.locator(".map-canvas")).toHaveClass(/screen-selection-active/); accentStrong: resolve("--accent-strong"),
await expect(selected).toHaveCount(1); hoverRing: resolve("--hover-ring"),
await expect.poll(async () => dimmed.count()).toBe((await screens.count()) - 1); quiet: resolve("--border-subtle"),
expect(await screens.evaluateAll(nodes => nodes.every(node => getComputedStyle(node).opacity === "1"))).toBe(true); 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);
// 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] : []; }
}));
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)) { /** The screenshot frame's box shadow on a Map card: where its ring is drawn. */
const hoverTarget = dimmed.nth(index); function mapCardRing(node: Locator) {
const hoverTargetId = await hoverTarget.getAttribute("data-id"); return node.locator(".screen-node-image :is(img, .image-placeholder)").first()
expect(hoverTargetId).not.toBeNull(); .evaluate((frame) => getComputedStyle(frame).boxShadow);
await hoverTarget.hover(); }
await expect.poll(() => hoverTarget.locator(":scope > .canvas-active-frame").evaluate(
(node) => Number.parseFloat(getComputedStyle(node).opacity), /** Each Map edge's id, ends and drawn stroke. */
)).toBe(1); function mapEdgeStrokes(page: Page) {
await expect(hoverTarget).toHaveCSS("filter", "none"); return page.locator(".map-canvas .react-flow__edge").evaluateAll((edges) => edges.map((edge) => {
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") ?? ""); const match = /^Edge from (.+) to (.+)$/.exec(edge.getAttribute("aria-label") ?? "");
if (!match) continue; const path = getComputedStyle(edge.querySelector(".transition-edge-path")!);
if (match[1] === nodeId) ids.add(match[2]!); return {
if (match[2] === nodeId) ids.add(match[1]!); id: edge.getAttribute("data-id") ?? "",
} from: match?.[1] ?? "",
return [...ids].sort(); to: match?.[2] ?? "",
}, hoverTargetId!); stroke: path.stroke,
const brightNodes = page.locator( strokeWidth: Number.parseFloat(path.strokeWidth),
".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") ?? "")
));
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);
}
} }
/**
* 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)
));
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 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. */ /** 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!); 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 }) => { 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"); await page.goto("/map");
const selected = page.locator(".map-canvas .react-flow__node-screen.selected"); 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 selected = page.locator(".map-canvas .react-flow__node-screen.selected");
const image = selected.locator(".screen-node-image img"); const image = selected.locator(".screen-node-image img");
await expect(image).toBeVisible(); await expect(image).toBeVisible();
await expectMapScreenSelectionDimming(page); await expectMapSelectionRing(page);
const pathStyle = await selected.locator(".screen-node-title").evaluate((element) => { const pathStyle = await selected.locator(".screen-node-title").evaluate((element) => {
const style = getComputedStyle(element); const style = getComputedStyle(element);
const bounds = element.getBoundingClientRect(); const bounds = element.getBoundingClientRect();
@@ -2042,13 +2080,18 @@ async function hoverableMapScreen(candidates: Locator, room = 80) {
return candidates.nth(index); 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 serveSyntheticWorkspace(page);
await page.goto("/map"); await page.goto("/map");
const screens = page.locator(".map-canvas .react-flow__node-screen:not(.canvas-node-exit)"); const screens = page.locator(".map-canvas .react-flow__node-screen:not(.canvas-node-exit)");
await expect(screens.first()).toBeVisible(); await expect(screens.first()).toBeVisible();
await expectMapCameraAtRest(page); await expectMapCameraAtRest(page);
const colors = await mapCanvasColors(page);
const resting = await mapCardOpacities(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. // 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) => ( 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) ?? []))] [...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( const node = await hoverableMapScreen(page.locator(
secondaryEnds.map((id) => `.map-canvas .react-flow__node-screen[data-id="${id}"]`).join(", "), 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 target = node.locator(".screen-screenshot-target");
const heading = node.locator(".screen-node-heading"); // No native title tooltip either; the heading names the screen.
// The tooltip says what a click does; no native title tooltip joins it.
await expect(target).not.toHaveAttribute("title"); 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())!; const box = (await target.boundingBox())!;
await target.hover({ position: { x: box.width / 2, y: box.height / 4 } }); await target.hover({ position: { x: box.width / 2, y: box.height / 4 } });
await expect(page.locator(".connection-canvas-surface.canvas-hovering")).toHaveCount(1); await expect(page.locator(".connection-canvas-surface.canvas-hovering")).toHaveCount(1);
const tooltip = page.locator(".tooltip", { hasText: "Open in Inspector" }); await expect.poll(() => mapCardRing(node)).toContain(colors.hoverRing);
await expect(tooltip).toBeVisible(); 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") const related = await page.locator(".map-canvas .react-flow__node-screen.graph-node-hover-related")
.evaluateAll((nodes) => nodes.map((element) => element.getAttribute("data-id") ?? "")); .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); expect(unrelated.length).toBeGreaterThan(0);
const hovering = await mapCardOpacities(page); const hovering = await mapCardOpacities(page);
expect(unrelated.map((id) => hovering[id])).toEqual(unrelated.map((id) => resting[id])); expect(unrelated.map((other) => hovering[other])).toEqual(unrelated.map((other) => resting[other]));
await expect(page.locator(".map-canvas .screen-open-hint:visible")).toHaveCount(0); // The transitions into and out of it come fully up in a darker grey, the secondary one too; the rest stay as they were.
// The transitions into and out of it come fully up, the secondary one too.
const incident = page.locator(".map-canvas .react-flow__edge.graph-edge-hover-related"); 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(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); 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 hoverEdges = await mapEdgeStrokes(page);
const clearance = async () => { for (const edge of hoverEdges) {
const [bubble, card, title] = await Promise.all([tooltip.boundingBox(), target.boundingBox(), heading.boundingBox()]); if (edge.from === id || edge.to === id) expect(edge.stroke, edge.id).toBe(colors.hoverEdge);
if (!bubble || !card || !title) return Number.NaN; else expect(edge.stroke, edge.id).toBe(restingEdges.find((resting) => resting.id === edge.id)!.stroke);
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);
}); });
test("hovering a Map screen the Changes filter muted brings it and its neighbours back up, and nothing else", async ({ page }) => { 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"; loading?: "eager" | "lazy";
leading?: ReactNode; leading?: ReactNode;
trailing?: ReactNode; trailing?: ReactNode;
/** Where the "Open in Inspector" tooltip sits: away from the route heading, which is above the screenshot on the Map. */ /** Say "Open in Inspector" in a tooltip over the screenshot (Screens). The Map's cards go without. */
tooltipPlacement?: "top" | "bottom"; inspectorTooltip?: boolean;
/** Short lines about the screen, inside the card after its screenshot (Screens: how it was reached, where else it changed). */ /** Short lines about the screen, inside the card after its screenshot (Screens: how it was reached, where else it changed). */
note?: ReactNode; note?: ReactNode;
onClick: MouseEventHandler<HTMLButtonElement>; onClick: MouseEventHandler<HTMLButtonElement>;
@@ -92,10 +92,10 @@ export function ScreenScreenshotCard(props: ScreenScreenshotCardProps) {
free of block children. */} free of block children. */}
<span className="screen-screenshot-slot"> <span className="screen-screenshot-slot">
{props.leading} {props.leading}
{/* With a pointer, what a click does is said once, zoom-independent, in the shared tooltip {/* On Screens, with a pointer, what a click does is said once in the shared tooltip after
after its usual delay; the selected screen is already in the Inspector. The button has its usual delay; the selected screen is already in the Inspector. The button has no
no title of its own, so no native tooltip joins it; the heading names the screen. */} 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)}> <Tooltip label="Open in Inspector" placement="top" disabled={props.inspectorTooltip === false || Boolean(props.selected)}>
<button <button
type="button" type="button"
className="screen-screenshot-target" className="screen-screenshot-target"
@@ -12,7 +12,8 @@ export type TransitionEdgeData = {
transitionCount: number; transitionCount: number;
active: boolean; active: boolean;
primary: 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; sourceOnly?: boolean;
previousSource?: boolean; previousSource?: boolean;
tooltip?: string; tooltip?: string;
@@ -39,9 +40,10 @@ export function TransitionEdge(props: EdgeProps<TransitionGraphEdge>) {
curvature: 0.24, curvature: 0.24,
}); });
const emphasized = Boolean(props.data?.active || props.selected || hovered); 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 const stroke = emphasized
? "var(--accent)" ? "var(--accent)"
: quiet ? "var(--border-subtle)"
: props.data?.previousSource ? "var(--danger)" : props.data?.primary ? "var(--graph-line)" : "var(--graph-line-soft)"; : props.data?.previousSource ? "var(--danger)" : props.data?.primary ? "var(--graph-line)" : "var(--graph-line-soft)";
return ( return (
@@ -66,9 +68,8 @@ export function TransitionEdge(props: EdgeProps<TransitionGraphEdge>) {
style={{ style={{
...props.style, ...props.style,
stroke, 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", 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); publishZoom(Math.round(zoom * 100) / 100);
}, [props.cameraReady, zoom]); }, [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(() => { useEffect(() => {
// Re-registering after selection changes publishes the new capability to the zoom menu. // 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. // 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"; import { createKeyHold } from "../../utils/key-hold";
const HOVER_CLEAR_DELAY = 180; const HOVER_CLEAR_DELAY = 180;
const PRESSABLE = 'button, a, summary, [role="button"]';
const MAP_LAYOUT_REVISION = "flat-v1"; const MAP_LAYOUT_REVISION = "flat-v1";
const MAP_FIT_VIEW_OPTIONS = { const MAP_FIT_VIEW_OPTIONS = {
padding: 0.04, padding: 0.04,
@@ -115,8 +116,8 @@ function ScreenNodeCard({ data, selected }: NodeProps<ScreenGraphNode>) {
imageHeight={data.screenshotSize?.imageHeight ?? data.frame.screen.height} imageHeight={data.screenshotSize?.imageHeight ?? data.frame.screen.height}
placeholderSize={data.frame.screen} placeholderSize={data.frame.screen}
loading="lazy" loading="lazy"
// The route heads the card, so the tooltip goes below it. // The ring says which screen is which; a click opening it in the Inspector needs no tooltip.
tooltipPlacement="bottom" inspectorTooltip={false}
leading={<Handle type="target" position={horizontal ? Position.Left : Position.Top} className="graph-handle" />} 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" />} trailing={<Handle type="source" position={horizontal ? Position.Right : Position.Bottom} className="graph-handle" />}
onMouseEnter={() => data.onHover(data.screen.id)} onMouseEnter={() => data.onHover(data.screen.id)}
@@ -342,8 +343,9 @@ function projectionElements(
const edges: TransitionGraphEdge[] = structure.groups.map((group) => { const edges: TransitionGraphEdge[] = structure.groups.map((group) => {
const hierarchyEdge = structure.primaryEdgeKeys.has(group.key); const hierarchyEdge = structure.primaryEdgeKeys.has(group.key);
const connected = group.from === selectedScreenId || group.to === selectedScreenId; const connected = group.from === selectedScreenId || group.to === selectedScreenId;
const dimmed = false;
const active = connected; 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 sourceOnly = group.transitionIds.length === 0 && Boolean(group.sourceEdges?.length);
const previousSource = group.sourceRevision === "baseline"; const previousSource = group.sourceRevision === "baseline";
const removed = previousSource || (!group.synthetic && diff?.screens.get(group.to)?.status === "removed"); const removed = previousSource || (!group.synthetic && diff?.screens.get(group.to)?.status === "removed");
@@ -356,25 +358,26 @@ function projectionElements(
const primary = hierarchyEdge; const primary = hierarchyEdge;
const stroke = active const stroke = active
? "var(--accent)" ? "var(--accent)"
: quiet ? "var(--border-subtle)"
: removed ? "var(--danger)" : primary ? "var(--graph-line)" : "var(--graph-line-soft)"; : removed ? "var(--danger)" : primary ? "var(--graph-line)" : "var(--graph-line-soft)";
return { return {
id: edgeElementId(group.key), id: edgeElementId(group.key),
source: group.from, source: group.from,
target: group.to, target: group.to,
type: "transition", 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: { markerEnd: {
type: MarkerType.ArrowClosed, type: MarkerType.ArrowClosed,
width: active || hierarchyEdge ? 14 : 11, width: active || (hierarchyEdge && !quiet) ? 14 : 11,
height: active || hierarchyEdge ? 14 : 11, height: active || (hierarchyEdge && !quiet) ? 14 : 11,
color: stroke, color: stroke,
}, },
style: { style: {
stroke, 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, 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 // 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. // the base edge layer so selected/highlighted paths still pass behind screen imagery.
zIndex: 0, zIndex: 0,
@@ -433,7 +436,7 @@ function sameTransitionEdge(a: TransitionGraphEdge, b: TransitionGraphEdge) {
&& a.data?.transitionCount === b.data?.transitionCount && a.data?.transitionCount === b.data?.transitionCount
&& a.data?.active === b.data?.active && a.data?.active === b.data?.active
&& a.data?.primary === b.data?.primary && a.data?.primary === b.data?.primary
&& a.data?.dimmed === b.data?.dimmed; && a.data?.quiet === b.data?.quiet;
} }
function reuseUnchangedElements( function reuseUnchangedElements(
@@ -557,7 +560,8 @@ function ConnectionCanvas(props: MapViewProps) {
}, [applyHover]); }, [applyHover]);
// The arrow keys (or h j k l) walk the map from the selected screen: along an edge in the // 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 // 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 { selectedScreenId } = props;
const selectedRef = useRef(selectedScreenId); const selectedRef = useRef(selectedScreenId);
selectedRef.current = selectedScreenId; selectedRef.current = selectedScreenId;
@@ -568,22 +572,39 @@ function ConnectionCanvas(props: MapViewProps) {
if (!structure) return undefined; if (!structure) return undefined;
return from ? mapKeyTarget(structure, from, direction) : mapKeyEntry(structure, direction); 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) => { const onKeyDown = (event: KeyboardEvent) => {
hold.interrupt(event); hold.interrupt(event);
if (event.repeat && hold.holding(event.code)) { event.preventDefault(); return; } if (event.repeat && hold.holding(event.code)) { event.preventDefault(); return; }
if (event.defaultPrevented || !shortcutsLive(event) || arrowsOwnedBy(event.target)) 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); const direction = mapKeyDirection(event);
if (!direction) return; if (!direction) return;
if (!structureRef.current) return; if (!structureRef.current) return;
event.preventDefault(); event.preventDefault();
let at = move(direction, selectedRef.current); let at = move(direction, selectedRef.current);
if (!at) return; if (!at) return;
selectScreen(at); walkTo(at);
hold.begin(event.code, () => { hold.begin(event.code, () => {
const target = move(direction, at); const target = move(direction, at);
if (!target) return false; if (!target) return false;
at = target; at = target;
selectScreen(target); walkTo(target);
return true; 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) .sort((left, right) => left.depth - right.depth || left.y - right.y || left.x - right.x || left.index - right.index)
.map(({ id }) => id), [layout.nodes]); .map(({ id }) => id), [layout.nodes]);
const phone = usePhoneLayout(); const phone = usePhoneLayout();
const selectedScreenVisible = Boolean(
props.selectedScreenId && layout.nodes.some((node) => node.id === props.selectedScreenId),
);
if (props.map.screens.length === 0) { if (props.map.screens.length === 0) {
const blockers = props.map.gaps.filter((gap) => gap.status === "open" && !gap.screenId).map((gap) => gap.message); const blockers = props.map.gaps.filter((gap) => gap.status === "open" && !gap.screenId).map((gap) => gap.message);
return ( return (
@@ -656,10 +674,7 @@ function ConnectionCanvas(props: MapViewProps) {
<div ref={surfaceRef} className="connection-canvas-surface map-surface"> <div ref={surfaceRef} className="connection-canvas-surface map-surface">
<CanvasStage <CanvasStage
ariaLabel="Screen map" ariaLabel="Screen map"
className={[ className="map-canvas"
"map-canvas",
selectedScreenVisible ? "screen-selection-active" : "",
].filter(Boolean).join(" ")}
nodes={layout.nodes} nodes={layout.nodes}
edges={layout.edges} edges={layout.edges}
nodeTypes={NODE_TYPES} 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 /* 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. */ background at a glance, high enough that the canvas keeps its shape. */
--dim-out: 0.35; --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-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); --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; --graph-line-soft: #c5c7ce;
/* One flat fill for a group — no border, no second tone inside it. */ /* One flat fill for a group — no border, no second tone inside it. */
--canvas-group: #f5f5f6; --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); color: var(--text);
background: var(--screen); background: var(--screen);
} }
@@ -480,6 +481,7 @@ code {
--graph-line: #696e77; --graph-line: #696e77;
--graph-line-soft: #3f4349; --graph-line-soft: #3f4349;
--canvas-group: #18191b; --canvas-group: #18191b;
--hover-ring: #5a6169;
} }
/* The canvas is a fixed map: dragging anywhere pans, while clicking an object selects it. */ /* The canvas is a fixed map: dragging anywhere pans, while clicking an object selects it. */
.graph-canvas .canvas-tool-pan, .graph-canvas .canvas-tool-pan,
@@ -499,27 +501,14 @@ code {
.graph-canvas .transition-edge-hitarea { cursor: pointer; pointer-events: stroke; } .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 .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-secondary { opacity: 0.72; }
.graph-canvas .graph-edge-dimmed { opacity: 0.14; }
.graph-canvas .graph-edge-active { opacity: 1; } .graph-canvas .graph-edge-active { opacity: 1; }
.graph-canvas .react-flow__node { transition: opacity 180ms ease, filter 180ms ease; } .graph-canvas .react-flow__node { transition: opacity 180ms ease, filter 180ms ease; }
.graph-canvas .canvas-focus-animating .react-flow__node { transition: none; } .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. */ /* 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); } .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. /* Hover never recedes anything, but where the Changes filter has dimmed the map, the hovered
They fade as focus dims them, by opacity alone: a filter would grey the card's opaque backing. screen and the screens it connects to come back up, with the transitions between them, so the
Summary cards retain their normal contrast so the selected screen's semantic context is legible. */ neighbourhood reads. These come after the dimming rule so the pointer's context wins. */
.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. */
.connection-canvas-surface.canvas-hovering .react-flow__node-screen.graph-node-hover-related { .connection-canvas-surface.canvas-hovering .react-flow__node-screen.graph-node-hover-related {
opacity: 1; opacity: 1;
--map-card-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 /* 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 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 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-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-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, .screen-node-image:hover > .image-placeholder,
@@ -707,8 +696,8 @@ code {
border-radius: 17px; border-radius: 17px;
pointer-events: none; pointer-events: none;
} }
/* Selection needs no ring: the canvas dims every other screen. The highlight ring stays for the /* Selection needs no overlay: the Map rings the screenshot and Screens frames the card. The
transient pointer-over state that panels project onto the canvas. */ highlight ring stays for the transient pointer-over state that panels project onto the canvas. */
.canvas-active-frame.is-highlighted::after { .canvas-active-frame.is-highlighted::after {
border-color: var(--accent); border-color: var(--accent);
box-shadow: 0 0 24px color-mix(in srgb, var(--accent) 24%, transparent); box-shadow: 0 0 24px color-mix(in srgb, var(--accent) 24%, transparent);
@@ -723,10 +712,9 @@ code {
pointer-events: none; pointer-events: none;
} }
/* A screen's handles are ports on its frame: they take the frame colour, whether that is the /* 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 status colour of a changed screen or the accent of a selected one, and a ring in the canvas
the canvas colour keeps them legible as connection points on the border. */ colour keeps them legible as connection points on the border. */
.screen-screenshot-card { --screen-frame: var(--graph-line); } .screen-screenshot-card { --screen-frame: var(--graph-line); }
.screen-screenshot-card:has(.screen-node-image:hover),
.screen-screenshot-card.selected, .screen-screenshot-card.selected,
.screen-screenshot-card.highlighted { --screen-frame: var(--accent); } .screen-screenshot-card.highlighted { --screen-frame: var(--accent); }
.screen-screenshot-card:is(.diff-added, .diff-modified, .diff-removed) { --screen-frame: var(--diff); } .screen-screenshot-card:is(.diff-added, .diff-modified, .diff-removed) { --screen-frame: var(--diff); }
@@ -738,23 +726,48 @@ code {
opacity: 1; opacity: 1;
} }
/* Hover is transient canvas state. Nothing recedes: the pointer's screen gets its ring, the /* A Map card's border is its status alone. Selection rings it from outside instead: an accent
transitions into and out of it turn accent, and the screens at their other ends take a tinted ring past a gap in the canvas colour, outside the status border, with a soft lift; hover draws
frame, so the neighbourhood reads without the rest of the map changing. Only the symmetric the same ring in grey. The ring scales with the canvas, so below a readable zoom its unit grows
difference of related nodes/edges receives a class, avoiding a React commit across the graph. */ to keep it about a screen pixel and a half wide (--canvas-zoom, set by the zoom bridge). */
.connection-canvas-surface.canvas-hovering .graph-edge-hover-related .transition-edge-path { .map-surface .screen-screenshot-card {
stroke: var(--accent) !important; --ring-unit: clamp(1px, 0.6px / var(--canvas-zoom, 1), 6px);
stroke-width: 2.2 !important; --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; 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 Map: an area is a meaningful destination, never an anonymous "X states" step. */
.semantic-summary-node { .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 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 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-screenshot-target { cursor: pointer; }
.screen-open-hint { .screen-open-hint {
position: absolute; position: absolute;
@@ -954,7 +967,7 @@ code {
.screen-open-hint > svg { width: 14px; height: 14px; flex: none; } .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 /* 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 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 { .phone-layout .map-canvas .screen-screenshot-card.selected .screen-open-hint {
display: inline-flex; display: inline-flex;
animation: screen-open-hint-in 140ms ease-out; animation: screen-open-hint-in 140ms ease-out;