mirror of
https://github.com/expo/explore.git
synced 2026-11-15 17:32:23 -10:00
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
934943fd11 | ||
|
|
9150a24cd9 |
No files matched your search
@@ -61,7 +61,13 @@ jobs:
|
||||
env:
|
||||
# npm cannot generate provenance for a private repository.
|
||||
NPM_CONFIG_PROVENANCE: "false"
|
||||
run: npm publish --access public
|
||||
VERSION: ${{ steps.version.outputs.version }}
|
||||
shell: bash
|
||||
# A prerelease (0.20.0-next.0) goes to the next tag, so latest keeps the last release.
|
||||
run: |
|
||||
set -euo pipefail
|
||||
if [[ "$VERSION" == *-* ]]; then tag=next; else tag=latest; fi
|
||||
npm publish --access public --tag "$tag"
|
||||
- name: Tag the release
|
||||
if: steps.version.outputs.publish == 'true'
|
||||
env:
|
||||
|
||||
@@ -580,7 +580,7 @@ npm test
|
||||
|
||||
- `npm test` rebuilds the CLI and the Viewer first, because the node tests run the compiled `dist/`. After one `npm run build`, `npm run test:node` skips the rebuild.
|
||||
- The agent runtimes and `eas-cli` are optional dependencies that only capture needs. Do not install with `--omit=optional`, which also drops esbuild's platform package.
|
||||
- To release, bump `version` in `package.json` and merge to main. The [publish workflow](.github/workflows/publish.yml) publishes any version npm does not have yet.
|
||||
- To release, bump `version` in `package.json` and merge to main. The [publish workflow](.github/workflows/publish.yml) publishes any version npm does not have yet. A prerelease version such as `0.20.0-next.0` goes to the `next` tag, so `latest` stays on the last release.
|
||||
|
||||
```sh
|
||||
npx playwright install chromium
|
||||
|
||||
Generated
+2
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "@expo/explore",
|
||||
"version": "0.19.8",
|
||||
"version": "0.20.0-next.0",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "@expo/explore",
|
||||
"version": "0.19.8",
|
||||
"version": "0.20.0-next.0",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@expo/repack-app": "0.10.1",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@expo/explore",
|
||||
"version": "0.19.8",
|
||||
"version": "0.20.0-next.0",
|
||||
"description": "Source-driven mobile app maps, deterministic CI capture, and visual reviews",
|
||||
"license": "MIT",
|
||||
"type": "module",
|
||||
|
||||
@@ -188,12 +188,11 @@ test("Map keeps selected elevated arrows behind screenshots without rendering na
|
||||
await expect(sourceHitArea.locator("title")).toHaveText("Source navigation\npush · app/home.tsx");
|
||||
await page.mouse.move(1320, 30);
|
||||
const dimmedComparisons = [];
|
||||
for (const presentation of ["muted", "selection"]) {
|
||||
// Only the Changes filter dims a screen; a selection fades nothing.
|
||||
for (const presentation of ["muted"]) {
|
||||
await page.evaluate(mode => {
|
||||
const profile = document.querySelector('.react-flow__node[data-id="profile"]');
|
||||
const canvas = document.querySelector(".map-canvas");
|
||||
profile.classList.toggle("graph-node-muted", mode === "muted");
|
||||
canvas.classList.toggle("screen-selection-active", mode === "selection");
|
||||
}, presentation);
|
||||
const dimmedWithArrows = await profileImage.screenshot({ animations: "disabled" });
|
||||
await page.locator(".map-surface .react-flow__edges").evaluate(node => { node.style.visibility = "hidden"; });
|
||||
@@ -216,7 +215,6 @@ test("Map keeps selected elevated arrows behind screenshots without rendering na
|
||||
}
|
||||
await page.evaluate(() => {
|
||||
document.querySelector('.react-flow__node[data-id="profile"]').classList.remove("graph-node-muted");
|
||||
document.querySelector(".map-canvas").classList.remove("screen-selection-active");
|
||||
});
|
||||
await page.getByRole("button", { name: "Open Profile", exact: true }).click();
|
||||
assert.equal(await page.evaluate(() => window.selectedScreen), "profile");
|
||||
|
||||
+184
-149
@@ -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.
|
||||
|
||||
@@ -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
@@ -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;
|
||||
|
||||
Reference in new issue
Block a user