mirror of
https://github.com/expo/explore.git
synced 2026-11-15 17:32:23 -10:00
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4a64b721e3 | ||
|
|
6c3cec73fa |
No files matched your search
@@ -1774,3 +1774,502 @@ test("a near-square landscape pair in a short window keeps both halves on screen
|
||||
}
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
/** A capture in a colour of its own, so every side of every screen is a screenshot of its own. */
|
||||
function tintedCapture(seed) {
|
||||
const picture = new PNG({ width: 32, height: 64 });
|
||||
for (let offset = 0; offset < picture.data.length; offset += 4) picture.data.set([(seed * 53) % 256, (seed * 101 + 40) % 256, (seed * 151 + 90) % 256, 255], offset);
|
||||
const bytes = PNG.sync.write(picture);
|
||||
const digest = createHash("sha256").update(bytes).digest("hex");
|
||||
return { bytes, sha256: digest, path: `assets/${digest}.png`, reference: `expo-explore-asset:${digest}.png`,
|
||||
record: { url: `https://artifact.expo-explore.invalid/${digest}.png`, sha256: digest, width: 32, height: 64 } };
|
||||
}
|
||||
|
||||
/**
|
||||
* `count` modified screens, screen-1 to screen-<count>, each with a Before and an After of its own. `seed` gives
|
||||
* another target its own captures. `screens[i]` holds screen-(i + 1)'s `before` and `after`. `sameAfter: { i: j }`
|
||||
* gives the screen at index i the After of the one at index j.
|
||||
*/
|
||||
async function changedScreensArchive(count, { seed = 1, runtime, sameAfter = {} } = {}) {
|
||||
const report = reportFixture();
|
||||
const home = report.review.surfaces[0];
|
||||
const route = id => ({ ...home.head, id, route: `/${id}`, path: `/${id}`, routeFile: `app/${id}.tsx`, logicalPath: `app/${id}.tsx` });
|
||||
const extra = [];
|
||||
const screens = [];
|
||||
report.assets = [];
|
||||
report.review.surfaces = Array.from({ length: count }, (_, index) => {
|
||||
const id = `screen-${index + 1}`;
|
||||
const before = tintedCapture(seed * 100 + index * 2);
|
||||
const after = sameAfter[index] !== undefined ? screens[sameAfter[index]].after : tintedCapture(seed * 100 + index * 2 + 1);
|
||||
screens.push({ id, before, after });
|
||||
for (const capture of [before, after]) {
|
||||
if (report.assets.some(asset => asset.sha256 === capture.sha256)) continue;
|
||||
report.assets.push({ sha256: capture.sha256, path: capture.path });
|
||||
extra.push({ name: capture.path, bytes: capture.bytes });
|
||||
}
|
||||
return { ...structuredClone(home), id, base: route(id), head: route(id),
|
||||
baseImage: { ...home.baseImage, ...before.record }, headImage: { ...home.headImage, ...after.record } };
|
||||
});
|
||||
const empty = { contract: "explore.navigation", edges: [], modalSurfaceIds: [], unresolved: [] };
|
||||
report.review.navigation = { base: structuredClone(empty), head: empty };
|
||||
if (runtime) report.review.runtime = { ...report.review.runtime, ...runtime };
|
||||
return { bytes: await archive(report, extra), screens };
|
||||
}
|
||||
|
||||
/** Records each screenshot request (reference, priority, when) and release on the page's report archives. */
|
||||
async function recordScreenshotReads(page) {
|
||||
await page.evaluate(async () => {
|
||||
const { ArtifactReportArchive } = await import("/src/utils/artifact-report.ts");
|
||||
window.reads = [];
|
||||
window.releases = [];
|
||||
const { resolve, release } = ArtifactReportArchive.prototype;
|
||||
ArtifactReportArchive.prototype.resolve = function (reference, priority) {
|
||||
window.reads.push({ reference, priority: priority ?? "lazy", at: performance.now() });
|
||||
return resolve.call(this, reference, priority);
|
||||
};
|
||||
ArtifactReportArchive.prototype.release = function (reference) {
|
||||
window.releases.push({ reference, at: performance.now() });
|
||||
return release.call(this, reference);
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
/** How many uses of each screenshot the shown report counts, by reference. */
|
||||
const screenshotUses = page => page.evaluate(async () => {
|
||||
const { activeArtifactReport } = await import("/src/utils/artifact-report.ts");
|
||||
return Object.fromEntries([...activeArtifactReport.loads.values()].map(load => [`expo-explore-asset:${load.sha256}.png`, load.users]));
|
||||
});
|
||||
|
||||
/** How many mounted images show each screenshot, by reference. */
|
||||
const mountedScreenshots = page => page.evaluate(() => {
|
||||
const counts = {};
|
||||
for (const image of document.querySelectorAll("img[data-screenshot-src]")) counts[image.dataset.screenshotSrc] = (counts[image.dataset.screenshotSrc] ?? 0) + 1;
|
||||
return counts;
|
||||
});
|
||||
|
||||
/** Every use the report counts belongs to an image on the page; nothing else holds a screenshot. */
|
||||
async function expectBalancedUses(page, message) {
|
||||
await expect.poll(async () => {
|
||||
const uses = await screenshotUses(page);
|
||||
const mounted = await mountedScreenshots(page);
|
||||
return Object.entries(uses).filter(([reference, users]) => users > (mounted[reference] ?? 0));
|
||||
}, { message }).toEqual([]);
|
||||
}
|
||||
|
||||
test("Compare reads the next screen's screenshots once it rests on a screen, never while an arrow is held, and they are released when it moves on", { timeout: 90_000 }, async t => {
|
||||
const { bytes, screens } = await changedScreensArchive(9);
|
||||
const { page, errors } = await harness(t, bytes, { app: true, open: false, query: "&view=compare&screen=screen-1" });
|
||||
await recordScreenshotReads(page);
|
||||
await chooseFile(page, bytes);
|
||||
const compare = page.locator(".compare-section");
|
||||
await expect(compare.locator(".compare-frame img")).toHaveCount(2);
|
||||
for (const image of await compare.locator(".compare-frame img").all()) await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
const position = compare.locator(".compare-nav-position");
|
||||
await expect(position).toHaveText(/^1 of 9$/);
|
||||
const shownAt = await page.evaluate(() => Math.min(...window.reads.filter(read => read.priority === "eager").map(read => read.at)));
|
||||
|
||||
// Resting on screen-1, its neighbour in the direction of travel (screen-2) is read, after the settle delay, as a
|
||||
// prefetch that leaves the next step's slots free.
|
||||
const prefetchesOf = screen => page.evaluate(references => window.reads.filter(read => read.priority === "prefetch" && references.includes(read.reference)),
|
||||
[screen.before.reference, screen.after.reference]);
|
||||
await expect.poll(async () => (await prefetchesOf(screens[1])).length).toBe(2);
|
||||
assert.ok((await prefetchesOf(screens[1]))[0].at - shownAt >= 240, "Nothing is read before Compare rests on the screen");
|
||||
assert.equal((await page.evaluate(() => window.reads.filter(read => read.priority === "prefetch"))).length, 2, "Only the neighbour is read");
|
||||
await expect.poll(() => screenshotUses(page)).toMatchObject({ [screens[1].before.reference]: 1, [screens[1].after.reference]: 1 });
|
||||
|
||||
// The step finds its pictures decoded: nothing new is decoded for them.
|
||||
await expect.poll(() => page.evaluate(() => window.createdUrls.length)).toBe(4);
|
||||
await page.keyboard.press("ArrowRight");
|
||||
await expect(position).toHaveText(/^2 of 9$/);
|
||||
for (const image of await compare.locator(".compare-frame img").all()) await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
assert.equal(await page.evaluate(() => window.createdUrls.length), 4, "The prefetched screenshots were shown without a new decode");
|
||||
|
||||
// A held arrow steps past several screens; nothing is read for a neighbour until it is released.
|
||||
await expect.poll(async () => (await prefetchesOf(screens[2])).length).toBe(2);
|
||||
const downAt = await page.evaluate(() => performance.now());
|
||||
await page.keyboard.down("ArrowRight");
|
||||
await expect.poll(async () => Number((await position.textContent()).split(" ")[0]), { timeout: 4000 }).toBeGreaterThanOrEqual(6);
|
||||
// The stage is marked while the key repeats, so the screenshots it passes appear without a fade.
|
||||
await expect(compare.locator(".compare-stage")).toHaveAttribute("data-screenshot-instant", "");
|
||||
await page.waitForTimeout(150);
|
||||
const upAt = await page.evaluate(() => performance.now());
|
||||
await page.keyboard.up("ArrowRight");
|
||||
await expect(compare.locator(".compare-stage")).not.toHaveAttribute("data-screenshot-instant", /.*/);
|
||||
const heldPrefetches = await page.evaluate(({ downAt, upAt }) => window.reads.filter(read => read.priority === "prefetch" && read.at > downAt && read.at <= upAt), { downAt, upAt });
|
||||
assert.deepEqual(heldPrefetches, [], "No neighbour was read while the arrow was held");
|
||||
const landed = Number((await position.textContent()).split(" ")[0]);
|
||||
const next = screens[landed];
|
||||
if (next) await expect.poll(async () => (await prefetchesOf(next)).length).toBe(2);
|
||||
|
||||
// Leaving Compare lets go of every screenshot it, and its prefetch, held.
|
||||
await page.getByRole("group", { name: "Canvas view" }).getByRole("button", { name: "Screens", exact: true }).click();
|
||||
await expect(page.locator(".screens-page")).toBeVisible();
|
||||
await expect(compare).toHaveCount(0);
|
||||
await expectBalancedUses(page, "Every use left after Compare belongs to an image on Screens");
|
||||
const uses = await screenshotUses(page);
|
||||
for (const screen of screens) assert.equal(uses[screen.before.reference] ?? 0, 0, `${screen.id}'s Before is no longer in use`);
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("a prefetch never holds a slot the screen the reviewer steps to needs, whichever way the step goes", { timeout: 20_000 }, async t => {
|
||||
const { page, errors } = await harness(t);
|
||||
const { bytes, shas } = await multiImageArchive(8);
|
||||
const result = await page.evaluate(async ({ bytes, identity, shas, probe }) => {
|
||||
const archive = await window.openReport(bytes, identity);
|
||||
const decodes = new Function(`return (${probe})()`)();
|
||||
const [shown, shownToo, ahead, aheadToo, behind, behindToo, later, laterToo] = shas.map(sha => archive.reference(sha));
|
||||
const settle = () => new Promise(resolve => setTimeout(resolve, 30));
|
||||
// The screen on show is still being read when Compare rests on it: its neighbour's prefetches wait.
|
||||
const visible = [archive.resolve(shown, "eager"), archive.resolve(shownToo, "eager")];
|
||||
await decodes.until(() => decodes.held() === 2);
|
||||
const waited = [archive.resolve(ahead, "prefetch"), archive.resolve(aheadToo, "prefetch")].map(read => read.then(() => "read", error => error.message));
|
||||
await settle();
|
||||
const heldWhileShownReads = decodes.held();
|
||||
// The reviewer steps the other way before they start: they are dropped, unread.
|
||||
archive.release(ahead);
|
||||
archive.release(aheadToo);
|
||||
const stepped = [archive.resolve(behind, "eager"), archive.resolve(behindToo, "eager")];
|
||||
await decodes.until(() => decodes.held() === 4);
|
||||
decodes.all();
|
||||
await Promise.all([...visible, ...stepped]);
|
||||
const dropped = await Promise.all(waited);
|
||||
|
||||
// Resting on that screen, its own neighbour's prefetches start, in the slots its reads have finished with.
|
||||
const running = [archive.resolve(later, "prefetch"), archive.resolve(laterToo, "prefetch")];
|
||||
await decodes.until(() => decodes.held() === 2);
|
||||
// The reviewer steps the other way while they run: they keep their slots, and the screen stepped to starts at once.
|
||||
archive.release(later);
|
||||
archive.release(laterToo);
|
||||
archive.release(shown);
|
||||
archive.release(shownToo);
|
||||
const back = [archive.resolve(shown, "eager"), archive.resolve(shownToo, "eager")];
|
||||
await settle();
|
||||
const heldAfterStep = decodes.held();
|
||||
decodes.all();
|
||||
await Promise.all([...running, ...back]);
|
||||
return { heldWhileShownReads, dropped, heldAfterStep, hashed: decodes.hashed() };
|
||||
}, { bytes, identity, shas, probe: decodeProbe.toString() });
|
||||
assert.equal(result.heldWhileShownReads, 2, "The prefetches waited while the shown screen was still being read");
|
||||
assert.deepEqual(result.dropped, ["This screenshot is no longer in use.", "This screenshot is no longer in use."]);
|
||||
assert.ok(!result.hashed.includes(shas[2]) && !result.hashed.includes(shas[3]), "A prefetch let go before it started was never read");
|
||||
assert.equal(result.heldAfterStep, 2, "The screen stepped to was read at once, beside the running prefetches");
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("Flip reads a screen's Before only once its After has loaded, and flipping reads nothing new", { timeout: 90_000 }, async t => {
|
||||
const { bytes, screens } = await changedScreensArchive(4);
|
||||
const { page, errors } = await harness(t, bytes, { app: true, open: false, query: "&view=compare&screen=screen-1" });
|
||||
await page.addInitScript(() => localStorage.setItem("expo-explore:compare-mode", "flip"));
|
||||
await page.reload();
|
||||
await recordScreenshotReads(page);
|
||||
await chooseFile(page, bytes);
|
||||
const frame = page.locator(".compare-section .compare-flip-frame");
|
||||
await expect(frame.locator(".compare-flip-layer")).toHaveCount(2);
|
||||
for (const image of await frame.locator("img").all()) await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
// The side off screen is hidden, its spinner with it.
|
||||
await expect(frame.locator(".compare-flip-layer[data-side='before']")).toHaveAttribute("aria-hidden", "true");
|
||||
await expect(frame.locator(".compare-flip-layer[data-side='before']")).toHaveCSS("visibility", "hidden");
|
||||
|
||||
// The next screen's After is held back: its Before is not read meanwhile, and only After's layer is mounted.
|
||||
await page.evaluate(after => {
|
||||
const digest = crypto.subtle.digest.bind(crypto.subtle);
|
||||
const hex = buffer => Array.from(new Uint8Array(buffer), byte => byte.toString(16).padStart(2, "0")).join("");
|
||||
window.heldAfter = [];
|
||||
crypto.subtle.digest = async (algorithm, data) => {
|
||||
const value = await digest(algorithm, data);
|
||||
if (hex(value) === after) await new Promise(resolve => window.heldAfter.push(resolve));
|
||||
return value;
|
||||
};
|
||||
}, screens[1].after.sha256);
|
||||
const readsOf = reference => page.evaluate(reference => window.reads.filter(read => read.reference === reference && read.priority !== "prefetch").length, reference);
|
||||
await page.keyboard.press("ArrowRight");
|
||||
await expect(page.locator(".compare-section .compare-nav-position")).toHaveText(/^2 of 4$/);
|
||||
await expect(frame.locator(".compare-flip-layer")).toHaveCount(1);
|
||||
await page.waitForTimeout(150);
|
||||
assert.equal(await readsOf(screens[1].before.reference), 0, "Before is not read while After loads");
|
||||
await page.evaluate(() => window.heldAfter.splice(0).forEach(release => release()));
|
||||
await expect(frame.locator(".compare-flip-layer")).toHaveCount(2);
|
||||
for (const image of await frame.locator("img").all()) await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
// StrictMode mounts each image's lease twice in development.
|
||||
assert.ok(await readsOf(screens[1].before.reference) > 0, "Before is read once After has loaded");
|
||||
|
||||
// Flipping swaps the two decoded sides at once.
|
||||
const reads = await page.evaluate(() => window.reads.length);
|
||||
await page.keyboard.press("KeyX");
|
||||
await expect(frame.locator(".compare-flip-layer[data-side='before']")).not.toHaveAttribute("aria-hidden", /.*/);
|
||||
await expect(frame.locator(".compare-flip-layer[data-side='after']")).toHaveCSS("visibility", "hidden");
|
||||
await expect(frame.locator(".compare-flip-layer[data-side='before'] img")).toHaveCSS("opacity", "1");
|
||||
await page.keyboard.press("KeyX");
|
||||
await expect(frame.locator(".compare-flip-layer[data-side='after']")).not.toHaveAttribute("aria-hidden", /.*/);
|
||||
assert.equal(await page.evaluate(() => window.reads.length), reads, "A flip reads nothing");
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("a Map card's backing draws the frame its screenshot waits and fades in over, and steps aside for No screenshot", { timeout: 60_000 }, async t => {
|
||||
const { page, errors } = await harness(t, await archive(), { app: true, fault: holdScreenshotHashes() });
|
||||
await expect(page.locator(".app-shell")).toBeVisible();
|
||||
const slot = page.locator(".map-canvas .screen-node-image").first();
|
||||
const image = slot.locator("img[data-screenshot-src]");
|
||||
const backing = slot.locator(".screenshot-backing");
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "loading");
|
||||
await expect(image).toHaveCSS("opacity", "0");
|
||||
await expect(backing).toHaveCSS("visibility", "visible");
|
||||
const frames = () => slot.evaluate(element => {
|
||||
const box = node => { const { left, top, width, height } = node.getBoundingClientRect(); return [left, top, width, height].map(value => Math.round(value * 10) / 10); };
|
||||
const style = node => { const { borderTopColor, borderTopWidth, borderTopLeftRadius, backgroundColor, boxShadow } = getComputedStyle(node); return { borderTopColor, borderTopWidth, borderTopLeftRadius, backgroundColor, boxShadow }; };
|
||||
const [img, backing] = [element.querySelector("img"), element.querySelector(".screenshot-backing")];
|
||||
return { image: box(img), backing: box(backing), imageStyle: style(img), backingStyle: style(backing) };
|
||||
});
|
||||
// The link selects Home, so the frame carries the selection ring past the Modified status.
|
||||
await expect(page.locator(".map-canvas .react-flow__node-screen.selected")).toHaveCount(1);
|
||||
// The ring follows the canvas zoom, and the backing's ring eases to it as the opening camera settles.
|
||||
await expect.poll(async () => { const { backingStyle, imageStyle } = await frames(); return backingStyle.boxShadow === imageStyle.boxShadow; }).toBe(true);
|
||||
const waiting = await frames();
|
||||
assert.deepEqual(waiting.backing, waiting.image, "The backing sits exactly where the image does");
|
||||
assert.deepEqual(waiting.backingStyle, waiting.imageStyle, "and draws the same frame: fill, border, radius, status and ring");
|
||||
assert.match(waiting.backingStyle.boxShadow, /rgb\(5, 136, 240\)/);
|
||||
|
||||
await page.evaluate(() => window.releaseScreenshotHashes());
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expect(image).toHaveAttribute("data-screenshot-reveal", "");
|
||||
assert.deepEqual((await frames()).image, waiting.image, "Loading moved nothing");
|
||||
// Once the picture has faded in, the backing hides.
|
||||
await expect(backing).toHaveCSS("visibility", "hidden");
|
||||
await expect(image).toHaveCSS("opacity", "1");
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("a Map card whose screenshot cannot be read shows No screenshot in one frame, its backing hidden", async t => {
|
||||
const damaged = Buffer.from(png);
|
||||
damaged[damaged.length - 1] ^= 1;
|
||||
const { page, errors } = await harness(t, await archive(reportFixture(), [], damaged), { app: true });
|
||||
await expect(page.locator(".app-shell")).toBeVisible();
|
||||
const slot = page.locator(".map-canvas .screen-node-image").first();
|
||||
await expect(slot.locator(".image-placeholder")).toHaveText("No screenshot");
|
||||
await expect(slot.locator(".screenshot-backing")).toHaveCSS("visibility", "hidden");
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("on a phone, a Screens card's screenshot keeps its height while it loads and once it has", { timeout: 60_000 }, async t => {
|
||||
const { bytes } = await changedScreensArchive(2);
|
||||
const { page, errors } = await harness(t, bytes, { app: true, open: false, fault: holdScreenshotHashes(tintedCapture(100).bytes.length) });
|
||||
await page.setViewportSize({ width: 390, height: 844 });
|
||||
await chooseFile(page, bytes);
|
||||
await expect(page.locator(".app-shell")).toBeVisible();
|
||||
await page.goto(`${page.url().split("#")[0]}#/screens`);
|
||||
const slot = page.locator(".screens-cell .screen-node-image.has-screenshot").first();
|
||||
await expect(slot).toBeVisible();
|
||||
const height = () => slot.evaluate(element => [element.getBoundingClientRect().height, element.querySelector("img").getBoundingClientRect().height]);
|
||||
const [waiting, waitingImage] = await height();
|
||||
assert.ok(waiting > 100 && Math.abs(waiting - waitingImage) < 1, `The waiting screenshot holds the slot open: ${waiting}, ${waitingImage}`);
|
||||
// The image is the frame here, and hidden while it loads: its backing draws the same frame in its place.
|
||||
await expect(slot.locator("img")).toHaveCSS("opacity", "0");
|
||||
const backing = slot.locator(".screenshot-backing");
|
||||
await expect(backing).toHaveCSS("visibility", "visible");
|
||||
const frames = await slot.evaluate(element => {
|
||||
const box = node => { const { left, top, width, height } = node.getBoundingClientRect(); return [left, top, width, height].map(value => Math.round(value)); };
|
||||
const style = node => { const { borderTopColor, borderTopWidth, borderTopLeftRadius, backgroundColor, boxShadow } = getComputedStyle(node); return { borderTopColor, borderTopWidth, borderTopLeftRadius, backgroundColor, boxShadow }; };
|
||||
const [img, backing] = [element.querySelector("img"), element.querySelector(".screenshot-backing")];
|
||||
return { image: box(img), backing: box(backing), imageStyle: style(img), backingStyle: style(backing) };
|
||||
});
|
||||
assert.deepEqual(frames.backing, frames.image);
|
||||
assert.deepEqual(frames.backingStyle, frames.imageStyle, "The backing draws the image's frame: border, fill, radius, status and ring");
|
||||
assert.notEqual(frames.backingStyle.backgroundColor, "rgba(0, 0, 0, 0)");
|
||||
// Selected, the backing carries the image's ring while the screenshot still loads (a changed screen's is its status).
|
||||
await page.goto(`${page.url().split("#")[0]}#/screens?screen=screen-1`);
|
||||
const selected = page.locator(".screens-cell .screen-screenshot-card.selected .screen-node-image");
|
||||
await expect(selected.locator("img")).toHaveAttribute("data-screenshot-state", "loading");
|
||||
const rings = await selected.evaluate(element => [element.querySelector("img"), element.querySelector(".screenshot-backing")]
|
||||
.map(node => getComputedStyle(node).boxShadow));
|
||||
assert.equal(rings[1], rings[0]);
|
||||
assert.notEqual(rings[1], "none");
|
||||
await page.evaluate(() => window.releaseScreenshotHashes());
|
||||
await expect(slot.locator("img")).toHaveAttribute("data-screenshot-state", "ready");
|
||||
assert.deepEqual(await height(), [waiting, waitingImage]);
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("a target switch blanks every card whose screenshot differs, never showing the other target's picture, and switching back reuses the kept pictures", { timeout: 90_000 }, async t => {
|
||||
const runtime = { platform: "android", platforms: ["ios", "android"] };
|
||||
const android = await changedScreensArchive(3, { seed: 1, runtime });
|
||||
const ios = await changedScreensArchive(3, { seed: 2, runtime: { ...runtime, platform: "ios" } });
|
||||
const preview = { token: "pqrstuvwxyz234567234567234567234", listing: [{ platform: "ios" }, { platform: "android" }],
|
||||
archives: { "?platform=ios": ios.bytes } };
|
||||
const { page, errors } = await harness(t, android.bytes, { app: true, reportIdentity: null, preview, query: "&platform=android" });
|
||||
await expect(page.locator(".app-shell")).toBeVisible();
|
||||
const cards = page.locator(".map-canvas img[data-screenshot-src]");
|
||||
await expect(cards).toHaveCount(3);
|
||||
for (const card of await cards.all()) await expect(card).toHaveAttribute("data-screenshot-state", "ready");
|
||||
const shown = await cards.evaluateAll(images => Object.fromEntries(images.map(image => [image.getAttribute("src"), image.dataset.screenshotSrc])));
|
||||
// Hold iOS's screenshots back so the switch is caught while they load.
|
||||
await page.evaluate(sizes => {
|
||||
const digest = crypto.subtle.digest.bind(crypto.subtle);
|
||||
window.heldIos = [];
|
||||
window.releaseIos = () => window.heldIos.splice(0).forEach(release => release());
|
||||
window.holdIos = true;
|
||||
crypto.subtle.digest = (algorithm, data) => window.holdIos && sizes.includes(data.byteLength)
|
||||
? new Promise(resolve => window.heldIos.push(() => resolve(digest(algorithm, data)))) : digest(algorithm, data);
|
||||
}, ios.screens.flatMap(screen => [screen.before.bytes.length, screen.after.bytes.length]));
|
||||
// Every frame from the switch on: no card shows a picture under another screenshot's name, and a waiting one is hidden.
|
||||
await page.evaluate(shown => {
|
||||
window.staleFrames = [];
|
||||
window.sampling = true;
|
||||
const sample = () => {
|
||||
for (const image of document.querySelectorAll(".map-canvas img[data-screenshot-src]")) {
|
||||
const source = shown[image.getAttribute("src")];
|
||||
const opacity = Number(getComputedStyle(image).opacity);
|
||||
if (source && source !== image.dataset.screenshotSrc && opacity > 0) window.staleFrames.push({ source, named: image.dataset.screenshotSrc, opacity });
|
||||
if (image.dataset.screenshotState === "loading" && opacity > 0) window.staleFrames.push({ waiting: image.dataset.screenshotSrc, opacity });
|
||||
}
|
||||
if (window.sampling) requestAnimationFrame(sample);
|
||||
};
|
||||
requestAnimationFrame(sample);
|
||||
}, shown);
|
||||
await page.getByRole("button", { name: "Platform: Android. Open another platform's report" }).click();
|
||||
await page.getByRole("menu", { name: "Platform" }).getByRole("menuitemradio").nth(0).click();
|
||||
await page.waitForURL(url => new URL(url).searchParams.get("platform") === "ios");
|
||||
await expect(cards.first()).toHaveAttribute("data-screenshot-src", ios.screens[0].after.reference);
|
||||
for (const card of await cards.all()) await expect(card).toHaveAttribute("data-screenshot-state", "loading");
|
||||
await page.waitForTimeout(200);
|
||||
await page.evaluate(() => { window.holdIos = false; window.releaseIos(); });
|
||||
for (const card of await cards.all()) await expect(card).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await page.evaluate(() => { window.sampling = false; });
|
||||
assert.deepEqual(await page.evaluate(() => window.staleFrames), [], "No frame showed Android's picture on iOS's cards, or a waiting picture");
|
||||
await expectBalancedUses(page, "After the switch, the iOS report counts only the cards' uses");
|
||||
|
||||
// Back to Android: its kept pictures come back without a new decode.
|
||||
const created = await page.evaluate(() => window.createdUrls.length);
|
||||
await page.goBack();
|
||||
await page.waitForURL(url => new URL(url).searchParams.get("platform") === "android");
|
||||
for (const card of await cards.all()) await expect(card).toHaveAttribute("data-screenshot-state", "ready");
|
||||
const back = await cards.evaluateAll(images => Object.fromEntries(images.map(image => [image.getAttribute("src"), image.dataset.screenshotSrc])));
|
||||
assert.deepEqual(back, shown, "Android's cards show the Blob URLs they showed before");
|
||||
assert.equal(await page.evaluate(() => window.createdUrls.length), created, "nothing was decoded again");
|
||||
await expectBalancedUses(page, "After switching back, the Android report counts only the cards' uses");
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("a prefetch the reviewer steps onto starts at once when a slot is free, instead of waiting for a running read", { timeout: 20_000 }, async t => {
|
||||
const { page, errors } = await harness(t);
|
||||
const { bytes, shas } = await multiImageArchive(4);
|
||||
const result = await page.evaluate(async ({ bytes, identity, shas, probe }) => {
|
||||
const archive = await window.openReport(bytes, identity);
|
||||
const decodes = new Function(`return (${probe})()`)();
|
||||
const [shown, shownToo, next, nextToo] = shas.map(sha => archive.reference(sha));
|
||||
// The screen on show is still being read after the rest: the next screen's prefetches wait behind the reserve.
|
||||
const visible = [archive.resolve(shown, "eager"), archive.resolve(shownToo, "eager")];
|
||||
await decodes.until(() => decodes.held() === 2);
|
||||
const prefetched = [archive.resolve(next, "prefetch"), archive.resolve(nextToo, "prefetch")];
|
||||
await new Promise(resolve => setTimeout(resolve, 30));
|
||||
const heldBeforeStep = decodes.held();
|
||||
// The reviewer steps onto that screen: its reads start in the two free slots, beside the running ones.
|
||||
const stepped = [archive.resolve(next, "eager"), archive.resolve(nextToo, "eager")];
|
||||
await new Promise(resolve => setTimeout(resolve, 30));
|
||||
const heldAfterStep = decodes.held();
|
||||
decodes.all();
|
||||
await Promise.all([...visible, ...prefetched, ...stepped]);
|
||||
return { heldBeforeStep, heldAfterStep, shared: await prefetched[0] === await stepped[0] };
|
||||
}, { bytes, identity, shas, probe: decodeProbe.toString() });
|
||||
assert.equal(result.heldBeforeStep, 2, "The prefetches waited behind the reserve");
|
||||
assert.equal(result.heldAfterStep, 4, "Stepped onto, they started at once");
|
||||
assert.equal(result.shared, true);
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("a prefetch read that never finishes does not stop Compare reading the next screens ahead", { timeout: 90_000 }, async t => {
|
||||
const { bytes, screens } = await changedScreensArchive(5);
|
||||
const { page, errors } = await harness(t, bytes, { app: true, open: false, query: "&view=compare&screen=screen-1" });
|
||||
await recordScreenshotReads(page);
|
||||
// Screen-2's Before never finishes verifying.
|
||||
await page.evaluate(stuck => {
|
||||
const digest = crypto.subtle.digest.bind(crypto.subtle);
|
||||
const hex = buffer => Array.from(new Uint8Array(buffer), byte => byte.toString(16).padStart(2, "0")).join("");
|
||||
crypto.subtle.digest = async (algorithm, data) => {
|
||||
const value = await digest(algorithm, data);
|
||||
if (hex(value) === stuck) await new Promise(() => {});
|
||||
return value;
|
||||
};
|
||||
}, screens[1].before.sha256);
|
||||
await chooseFile(page, bytes);
|
||||
const compare = page.locator(".compare-section");
|
||||
await expect(compare.locator(".compare-frame img[data-screenshot-state='ready']")).toHaveCount(2);
|
||||
const prefetchesOf = screen => page.evaluate(references => window.reads.filter(read => read.priority === "prefetch" && references.includes(read.reference)).length,
|
||||
[screen.before.reference, screen.after.reference]);
|
||||
await expect.poll(() => prefetchesOf(screens[1])).toBe(2);
|
||||
await page.keyboard.press("ArrowRight");
|
||||
await expect(compare.locator(".compare-nav-position")).toHaveText(/^2 of 5$/);
|
||||
await expect.poll(() => prefetchesOf(screens[2])).toBe(2);
|
||||
await page.keyboard.press("ArrowRight");
|
||||
await expect(compare.locator(".compare-nav-position")).toHaveText(/^3 of 5$/);
|
||||
await expect.poll(() => prefetchesOf(screens[3])).toBe(2);
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
/** Opens Compare in Flip at `screen`, recording screenshot reads. */
|
||||
async function openFlip(t, bytes, screen) {
|
||||
const opened = await harness(t, bytes, { app: true, open: false, query: `&view=compare&screen=${screen}` });
|
||||
await opened.page.addInitScript(() => localStorage.setItem("expo-explore:compare-mode", "flip"));
|
||||
await opened.page.reload();
|
||||
await recordScreenshotReads(opened.page);
|
||||
return opened;
|
||||
}
|
||||
|
||||
/** Holds back verifying the screenshot with this hash until `window.releaseHeld()`. */
|
||||
const holdScreenshot = (page, sha256) => page.evaluate(held => {
|
||||
const digest = crypto.subtle.digest.bind(crypto.subtle);
|
||||
const hex = buffer => Array.from(new Uint8Array(buffer), byte => byte.toString(16).padStart(2, "0")).join("");
|
||||
const waiting = [];
|
||||
window.releaseHeld = () => waiting.splice(0).forEach(release => release());
|
||||
crypto.subtle.digest = async (algorithm, data) => {
|
||||
const value = await digest(algorithm, data);
|
||||
if (hex(value) === held) await new Promise(resolve => waiting.push(resolve));
|
||||
return value;
|
||||
};
|
||||
}, sha256);
|
||||
|
||||
test("Flip reads the next screen's Before when a step keeps the After it shows, which fires no load", { timeout: 90_000 }, async t => {
|
||||
// Screen-2 keeps screen-1's After beside a Before of its own.
|
||||
const { bytes, screens } = await changedScreensArchive(3, { sameAfter: { 1: 0 } });
|
||||
const { page, errors } = await openFlip(t, bytes, "screen-1");
|
||||
await chooseFile(page, bytes);
|
||||
const frame = page.locator(".compare-section .compare-flip-frame");
|
||||
await expect(frame.locator(".compare-flip-layer img[data-screenshot-state='ready']")).toHaveCount(2);
|
||||
await page.keyboard.press("ArrowRight");
|
||||
await expect(page.locator(".compare-section .compare-nav-position")).toHaveText(/^2 of 3$/);
|
||||
await expect(frame.locator(".compare-flip-layer[data-side='before'] img")).toHaveAttribute("data-screenshot-src", screens[1].before.reference);
|
||||
await expect(frame.locator(".compare-flip-layer img[data-screenshot-state='ready']")).toHaveCount(2);
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("Flip stepped from Before shows the next screen's After from its first frame and reads its Before only once After is ready", { timeout: 90_000 }, async t => {
|
||||
const { bytes, screens } = await changedScreensArchive(3);
|
||||
const { page, errors } = await openFlip(t, bytes, "screen-1");
|
||||
await chooseFile(page, bytes);
|
||||
const frame = page.locator(".compare-section .compare-flip-frame");
|
||||
await expect(frame.locator(".compare-flip-layer img[data-screenshot-state='ready']")).toHaveCount(2);
|
||||
await page.keyboard.press("KeyX");
|
||||
await expect(frame).toHaveAttribute("data-side", "before");
|
||||
await holdScreenshot(page, screens[1].after.sha256);
|
||||
// Every frame from the step: which side the frame shows, and which layers are mounted.
|
||||
await page.evaluate(() => {
|
||||
window.flipFrames = [];
|
||||
const sample = () => {
|
||||
const element = document.querySelector(".compare-flip-frame");
|
||||
window.flipFrames.push({ route: document.querySelector(".compare-nav-route")?.textContent, side: element?.dataset.side,
|
||||
layers: [...(element?.querySelectorAll(".compare-flip-layer") ?? [])].map(layer => layer.dataset.side).join(",") });
|
||||
if (window.flipFrames.length < 20) requestAnimationFrame(sample);
|
||||
};
|
||||
requestAnimationFrame(sample);
|
||||
});
|
||||
await page.keyboard.press("ArrowRight");
|
||||
await expect.poll(() => page.evaluate(() => window.flipFrames.length)).toBe(20);
|
||||
const stepped = (await page.evaluate(() => window.flipFrames)).filter(sample => sample.route === "/screen-2");
|
||||
assert.ok(stepped.length > 0);
|
||||
assert.deepEqual([...new Set(stepped.map(sample => `${sample.side}:${sample.layers}`))], ["after:after"],
|
||||
"From its first frame screen-2 shows After alone");
|
||||
const readsOf = reference => page.evaluate(reference => window.reads.filter(read => read.reference === reference && read.priority !== "prefetch").length, reference);
|
||||
assert.equal(await readsOf(screens[1].before.reference), 0, "Before waits for After");
|
||||
await page.evaluate(() => window.releaseHeld());
|
||||
await expect(frame.locator(".compare-flip-layer img[data-screenshot-state='ready']")).toHaveCount(2);
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
@@ -48,6 +48,8 @@ const entry = `
|
||||
import { useEffect, useState } from "react";
|
||||
import { createRoot } from "react-dom/client";
|
||||
import { ScreenshotImage } from "/src/components/shared/screenshot-image.tsx";
|
||||
// The Viewer's own rules hide a waiting screenshot and fade a ready one in.
|
||||
if (window.fixture.styles) await import("/src/styles.css");
|
||||
|
||||
function Harness() {
|
||||
const [state, setState] = useState(window.fixture);
|
||||
@@ -66,10 +68,13 @@ function Harness() {
|
||||
return <main style={{ position: "relative", height: state.layout === "scroll" ? 3300 : 300,
|
||||
width: 600, overflow: state.layout === "pan" ? "hidden" : undefined }}>
|
||||
{state.normalSource && <ScreenshotImage src={state.normalSource} alt="Hosted screenshot"
|
||||
width={24} height={18} decoding="async" onLoad={loaded} />}
|
||||
width={24} height={18} decoding="async" onLoad={loaded} {...(state.holdPrevious ? { holdPrevious: true } : {})}
|
||||
{...(state.fallback ? { fallback: <span data-testid="hosted-fallback">No hosted screenshot</span> } : {})} />}
|
||||
<div data-testid="positioner" style={{ position: "absolute", left: 20,
|
||||
top: state.layout === "scroll" ? 3000 : 30,
|
||||
transform: state.layout === "pan" ? "translateX(2500px)" : undefined }}>
|
||||
transform: state.layout === "pan" ? "translateX(2500px)" : undefined }}
|
||||
{...(state.instant ? { "data-screenshot-instant": "" } : {})}
|
||||
{...(state.thumbnail ? { className: "variant-thumbnail", "aria-selected": "false" } : {})}>
|
||||
{state.mounted !== false && <ScreenshotImage src={state.source} alt="Captured checkout"
|
||||
width={120} height={80} loading={state.loading} decoding="async" className="captured-image"
|
||||
data-screen="checkout" onLoad={loaded} onError={failed}
|
||||
@@ -106,6 +111,18 @@ async function fixture(t, options = {}) {
|
||||
response.end(firstImage);
|
||||
return;
|
||||
}
|
||||
// A hosted screenshot that is not there.
|
||||
if (request.url === "/__missing.png") {
|
||||
response.statusCode = 404;
|
||||
response.end("Not found");
|
||||
return;
|
||||
}
|
||||
// A hosted screenshot that takes a while to arrive.
|
||||
if (request.url === "/__slow.png") {
|
||||
response.setHeader("Content-Type", "image/png");
|
||||
setTimeout(() => response.end(secondImage), 600);
|
||||
return;
|
||||
}
|
||||
if (request.url !== "/") return next();
|
||||
response.setHeader("Content-Type", "text/html");
|
||||
response.end('<!doctype html><html><head><style>body{margin:0}</style></head><body><div id="root"></div><script type="module" src="/__screenshot_image.tsx"></script></body></html>');
|
||||
@@ -163,7 +180,15 @@ async function fixture(t, options = {}) {
|
||||
window.pendingScreenshots.delete(source);
|
||||
for (const { reject } of pending) reject(new Error("Screenshot resolution failed"));
|
||||
};
|
||||
if (fixture.decode === "manual") {
|
||||
// The test settles each decode; one it never settles stands in for a decode that hangs.
|
||||
window.pendingDecodes = [];
|
||||
HTMLImageElement.prototype.decode = function () {
|
||||
return new Promise((resolve, reject) => window.pendingDecodes.push({ image: this, resolve, reject }));
|
||||
};
|
||||
}
|
||||
}, { source: firstSource, layout: "visible", ...options });
|
||||
if (options.reducedMotion) await page.emulateMedia({ reducedMotion: "reduce" });
|
||||
await page.goto(`http://127.0.0.1:${address.port}/`);
|
||||
await page.waitForFunction(() => window.harnessReady);
|
||||
return { page, image: page.getByRole("img", { name: "Captured checkout", exact: true }) };
|
||||
@@ -505,3 +530,187 @@ test("an image that leaves and re-enters the viewport within one render is ready
|
||||
await expect(image).not.toHaveAttribute("aria-busy", /.*/);
|
||||
assert.equal(await page.evaluate(() => window.imageLoads.length), 1, "No second load event fired");
|
||||
});
|
||||
|
||||
/** The image's opacity and state in each of the next `frames` frames, from the frame after `change` runs. */
|
||||
async function framesAfter(page, change, frames = 4, selector = "img[alt='Captured checkout']") {
|
||||
return page.evaluate(({ change, frames, selector }) => new Promise(resolve => {
|
||||
const samples = [];
|
||||
new Function(change)();
|
||||
const sample = () => {
|
||||
const image = document.querySelector(selector);
|
||||
samples.push(image ? { source: image.dataset.screenshotSrc ?? image.getAttribute("src"),
|
||||
state: image.dataset.screenshotState, opacity: getComputedStyle(image).opacity } : undefined);
|
||||
if (samples.length < frames) requestAnimationFrame(sample);
|
||||
else resolve(samples);
|
||||
};
|
||||
requestAnimationFrame(sample);
|
||||
}), { change, frames, selector });
|
||||
}
|
||||
|
||||
/** The reveal animation on the image, paused and sought to `at` milliseconds: its opacity there. */
|
||||
async function revealOpacityAt(image, at) {
|
||||
return image.evaluate((element, at) => {
|
||||
const [animation] = element.getAnimations().filter(animation => animation.animationName === "screenshot-reveal");
|
||||
if (!animation) return undefined;
|
||||
animation.pause();
|
||||
animation.currentTime = at;
|
||||
return Number(getComputedStyle(element).opacity);
|
||||
}, at);
|
||||
}
|
||||
|
||||
test("a waiting screenshot is hidden from its first frame, and one that fills its empty frame fades in", { timeout: 30_000 }, async t => {
|
||||
const { page, image } = await fixture(t, { loading: "eager", styles: true });
|
||||
await expect.poll(() => page.evaluate(() => window.resolverCalls)).toEqual([firstSource]);
|
||||
await expect(image).toHaveCSS("opacity", "0");
|
||||
await resolveImage(page, firstSource);
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expect(image).toHaveAttribute("data-screenshot-reveal", "");
|
||||
assert.equal(await revealOpacityAt(image, 0), 0, "The fade starts from nothing");
|
||||
const midway = await revealOpacityAt(image, 80);
|
||||
assert.ok(midway > 0 && midway < 1, `Halfway through the fade the picture is partly shown (${midway})`);
|
||||
await image.evaluate(element => element.getAnimations().forEach(animation => animation.finish()));
|
||||
await expect(image).toHaveCSS("opacity", "1");
|
||||
|
||||
// Another source: the picture before is hidden in the very frame the new source lands, never faded out.
|
||||
const samples = await framesAfter(page, `window.updateScreenshot({ source: ${JSON.stringify(secondSource)} })`);
|
||||
const landed = samples.filter(sample => sample?.source === secondSource);
|
||||
assert.ok(landed.length > 0, "The new source landed within a few frames");
|
||||
assert.deepEqual(landed.map(sample => sample.opacity), landed.map(() => "0"));
|
||||
assert.deepEqual(samples.filter(sample => sample?.source !== secondSource).map(sample => sample.opacity),
|
||||
samples.filter(sample => sample?.source !== secondSource).map(() => "1"), "Until then, the shown picture is the one it names");
|
||||
assert.deepEqual(await image.evaluate(element => element.getAnimations().map(animation => animation.constructor.name)), [],
|
||||
"Nothing animates the hiding");
|
||||
});
|
||||
|
||||
test("a loaded screenshot is shown only once it has decoded, or after a short wait for a decode that hangs", { timeout: 30_000 }, async t => {
|
||||
const { page, image } = await fixture(t, { loading: "eager", styles: true, decode: "manual" });
|
||||
await resolveImage(page, firstSource);
|
||||
// The caller hears the load at once (Compare takes its shape from it); the picture waits for its pixels.
|
||||
await expect.poll(() => page.evaluate(() => window.imageLoads.length)).toBe(1);
|
||||
await expect.poll(() => page.evaluate(() => window.pendingDecodes.length)).toBe(1);
|
||||
await page.waitForTimeout(100);
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "loading");
|
||||
await expect(image).toHaveCSS("opacity", "0");
|
||||
await page.evaluate(() => window.pendingDecodes.shift().resolve());
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expect(image).toHaveAttribute("data-screenshot-reveal", "");
|
||||
|
||||
// A decode that never settles: shown anyway, with its fade.
|
||||
await page.evaluate(source => window.updateScreenshot({ source }), secondSource);
|
||||
await resolveImage(page, secondSource, secondImage);
|
||||
await expect.poll(() => page.evaluate(() => window.pendingDecodes.length)).toBe(1);
|
||||
const loadedAt = await page.evaluate(() => performance.now());
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
const waited = await page.evaluate(() => performance.now()) - loadedAt;
|
||||
assert.ok(waited >= 200, `The hung decode was waited for before the picture was shown (${Math.round(waited)}ms)`);
|
||||
await expect(image).toHaveAttribute("data-screenshot-reveal", "");
|
||||
assert.equal(await image.evaluate(element => element.naturalWidth), 4);
|
||||
});
|
||||
|
||||
test("a screenshot the report still holds decoded fades in when it is shown again", { timeout: 30_000 }, async t => {
|
||||
const { page, image } = await fixture(t, { loading: "eager", styles: true });
|
||||
const url = await blobUrl(page, firstImage);
|
||||
await expect.poll(() => page.evaluate(() => window.resolverCalls)).toEqual([firstSource]);
|
||||
await page.evaluate(({ source, url }) => window.resolveScreenshot(source, url), { source: firstSource, url });
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
|
||||
// Shown again (Compare stepping back to it, a view mounting again) while the report still holds its decoded URL.
|
||||
await page.evaluate(() => window.updateScreenshot({ mounted: false }));
|
||||
await expect(image).toHaveCount(0);
|
||||
await page.evaluate(({ source, url }) => {
|
||||
window.immediateScreenshots.set(source, url);
|
||||
window.updateScreenshot({ mounted: true });
|
||||
}, { source: firstSource, url });
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expect(image).toHaveAttribute("data-screenshot-reveal", "");
|
||||
assert.equal(await revealOpacityAt(image, 0), 0);
|
||||
});
|
||||
|
||||
test("an ordinary URL is a new image for each source and never shows the one before while it loads", { timeout: 30_000 }, async t => {
|
||||
const { page } = await fixture(t, { loading: "eager", styles: true, normalSource: "/__normal.png" });
|
||||
const hosted = page.getByRole("img", { name: "Hosted screenshot", exact: true });
|
||||
await expect(hosted).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expect(hosted).toHaveAttribute("data-screenshot-reveal", "");
|
||||
await hosted.evaluate(element => { element.dataset.first = "true"; });
|
||||
|
||||
const samples = await framesAfter(page, "window.updateScreenshot({ normalSource: '/__slow.png' })", 6, "img[alt='Hosted screenshot']");
|
||||
const landed = samples.filter(sample => sample?.source === "/__slow.png");
|
||||
assert.ok(landed.length > 0);
|
||||
assert.deepEqual(landed.map(sample => [sample.state, sample.opacity]), landed.map(() => ["loading", "0"]));
|
||||
await expect(hosted).not.toHaveAttribute("data-first", /.*/);
|
||||
await expect(hosted).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expect(hosted).toHaveAttribute("data-screenshot-reveal", "");
|
||||
await expectDecoded(hosted, 4, 5);
|
||||
});
|
||||
|
||||
test("a held picture stays shown while its replacement loads, and the replacement appears without a fade", { timeout: 30_000 }, async t => {
|
||||
const { page, image } = await fixture(t, { loading: "eager", styles: true, holdPrevious: true, fallback: true });
|
||||
await resolveImage(page, firstSource);
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await page.evaluate(source => window.updateScreenshot({ source }), secondSource);
|
||||
await expect(image).toHaveAttribute("data-screenshot-held", "");
|
||||
await expect(image).toHaveCSS("opacity", "1");
|
||||
await resolveImage(page, secondSource, secondImage);
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expectDecoded(image, 4, 5);
|
||||
await expect(image).not.toHaveAttribute("data-screenshot-reveal", /.*/);
|
||||
await expect(image).not.toHaveAttribute("data-screenshot-held", /.*/);
|
||||
assert.deepEqual(await image.evaluate(element => element.getAnimations().length), 0);
|
||||
});
|
||||
|
||||
test("inside an instant stage a picture appears at once", { timeout: 30_000 }, async t => {
|
||||
const { page, image } = await fixture(t, { loading: "eager", styles: true, instant: true });
|
||||
await resolveImage(page, firstSource);
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expect(image).not.toHaveAttribute("data-screenshot-reveal", /.*/);
|
||||
await expect(image).toHaveCSS("opacity", "1");
|
||||
});
|
||||
|
||||
test("with reduced motion a screenshot appears without a fade", { timeout: 30_000 }, async t => {
|
||||
const { page, image } = await fixture(t, { loading: "eager", styles: true, reducedMotion: true });
|
||||
await resolveImage(page, firstSource);
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
// The Viewer's reduced-motion rule leaves every transition a hundredth of a millisecond long; the fade is gone.
|
||||
assert.deepEqual(await image.evaluate(element => element.getAnimations().map(animation => animation.animationName).filter(Boolean)), []);
|
||||
await expect(image).toHaveCSS("opacity", "1");
|
||||
});
|
||||
|
||||
test("an unselected variant thumbnail that changes source hides at once, despite its own dimmed opacity and its transition", { timeout: 30_000 }, async t => {
|
||||
const { page, image } = await fixture(t, { loading: "eager", styles: true, thumbnail: true });
|
||||
await resolveImage(page, firstSource);
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await image.evaluate(element => element.getAnimations().forEach(animation => animation.finish()));
|
||||
await expect(image).toHaveCSS("opacity", "0.35");
|
||||
const samples = await framesAfter(page, `window.updateScreenshot({ source: ${JSON.stringify(secondSource)} })`);
|
||||
const landed = samples.filter(sample => sample?.source === secondSource);
|
||||
assert.ok(landed.length > 0);
|
||||
assert.deepEqual(landed.map(sample => sample.opacity), landed.map(() => "0"));
|
||||
});
|
||||
|
||||
test("an ordinary URL that cannot be loaded shows the fallback, and a held one gives way to it", { timeout: 30_000 }, async t => {
|
||||
const { page } = await fixture(t, { loading: "eager", styles: true, fallback: true, holdPrevious: true, normalSource: "/__normal.png" });
|
||||
const hosted = page.getByRole("img", { name: "Hosted screenshot", exact: true });
|
||||
await expect(hosted).toHaveAttribute("data-screenshot-state", "ready");
|
||||
// The app icon's case: a held picture whose replacement is missing ends on the fallback, not on the picture before.
|
||||
await page.evaluate(() => window.updateScreenshot({ normalSource: "/__missing.png" }));
|
||||
await expect(page.getByTestId("hosted-fallback")).toHaveText("No hosted screenshot");
|
||||
await expect(hosted).toHaveCount(0);
|
||||
// A new source tries again.
|
||||
await page.evaluate(() => window.updateScreenshot({ normalSource: "/__normal.png" }));
|
||||
await expect(hosted).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expect(page.getByTestId("hosted-fallback")).toHaveCount(0);
|
||||
});
|
||||
|
||||
test("re-rendering an image that waits for its decode starts no second wait", { timeout: 30_000 }, async t => {
|
||||
const { page, image } = await fixture(t, { loading: "eager", styles: true, decode: "manual" });
|
||||
await resolveImage(page, firstSource);
|
||||
await expect.poll(() => page.evaluate(() => window.pendingDecodes.length)).toBe(1);
|
||||
// Renders while the decode is pending find the image loaded but not shown yet.
|
||||
for (let render = 0; render < 5; render++) {
|
||||
await page.evaluate(render => window.updateScreenshot({ render }), render);
|
||||
await page.evaluate(() => new Promise(resolve => requestAnimationFrame(resolve)));
|
||||
}
|
||||
assert.equal(await page.evaluate(() => window.pendingDecodes.length), 1, "One decode wait for the one picture");
|
||||
await page.evaluate(() => window.pendingDecodes.shift().resolve());
|
||||
await expect(image).toHaveAttribute("data-screenshot-state", "ready");
|
||||
});
|
||||
@@ -5,11 +5,13 @@ import { chromium, expect } from "@playwright/test";
|
||||
import { PNG } from "pngjs";
|
||||
import { createBrowserVite } from "../helpers/browser-vite.mjs";
|
||||
|
||||
function png(width, height, color) {
|
||||
function pngBytes(width, height, color) {
|
||||
const image = new PNG({ width, height });
|
||||
for (let index = 0; index < image.data.length; index += 4) image.data.set([...color, 255], index);
|
||||
return `data:image/png;base64,${PNG.sync.write(image).toString("base64")}`;
|
||||
return PNG.sync.write(image);
|
||||
}
|
||||
const png = (width, height, color) => `data:image/png;base64,${pngBytes(width, height, color).toString("base64")}`;
|
||||
const GREEN = [40, 200, 40];
|
||||
|
||||
// Split over one screen with two changed areas and a card that moved 40% of the width right (at 60% in After, so
|
||||
// at 20% in Before), and a second screen with one changed area elsewhere. The status bar CI left out is a foldable's
|
||||
@@ -45,7 +47,9 @@ function Harness() {
|
||||
window.addEventListener("keydown", onKey);
|
||||
return () => window.removeEventListener("keydown", onKey);
|
||||
}, []);
|
||||
const diff = { id: "s" + screen, status: "modified", beforeScreenshot: window.before, afterScreenshot: window.after };
|
||||
// The second screen has screenshots of its own when the test gives it some.
|
||||
const diff = { id: "s" + screen, status: "modified", beforeScreenshot: screen && window.nextBefore || window.before,
|
||||
afterScreenshot: screen && window.nextAfter || window.after };
|
||||
return (
|
||||
<div className={"compare-stage mode-" + mode} style={{ width: 800, height: 500, display: "flex" }}>
|
||||
<CompareStage key="stage" mode={mode} diff={diff} title="Share" areas={screens[screen]} activeArea={active}
|
||||
@@ -57,7 +61,7 @@ function Harness() {
|
||||
createRoot(document.getElementById("root")).render(<Harness />);
|
||||
`;
|
||||
|
||||
async function openSplit(t, contextOptions = {}) {
|
||||
async function openSplit(t, contextOptions = {}, images = {}) {
|
||||
const vite = await createBrowserVite(t, {
|
||||
configFile: false, root: fileURLToPath(new URL("../../viewer", import.meta.url)),
|
||||
logLevel: "error", esbuild: { jsx: "automatic" },
|
||||
@@ -67,6 +71,12 @@ async function openSplit(t, contextOptions = {}) {
|
||||
load: id => id === "/__split-outlines.tsx" ? entry : undefined,
|
||||
configureServer(server) {
|
||||
server.middlewares.use((request, response, next) => {
|
||||
// The next screen's Before, which takes a while to arrive.
|
||||
if (request.url === "/__slow-before.png") {
|
||||
response.setHeader("Content-Type", "image/png");
|
||||
setTimeout(() => response.end(pngBytes(100, 100, GREEN)), 1000);
|
||||
return;
|
||||
}
|
||||
if (new URL(request.url, "http://localhost").pathname !== "/") return next();
|
||||
response.setHeader("Content-Type", "text/html");
|
||||
response.end('<!doctype html><html><body style="margin:0"><div id="root"></div><script type="module" src="/__split-outlines.tsx"></script></body></html>');
|
||||
@@ -82,7 +92,7 @@ async function openSplit(t, contextOptions = {}) {
|
||||
const errors = [];
|
||||
page.on("pageerror", error => errors.push(error.message));
|
||||
t.after(() => assert.deepEqual(errors, []));
|
||||
await page.addInitScript(images => Object.assign(window, images), { before: png(100, 100, [240, 240, 240]), after: png(100, 100, [230, 230, 230]) });
|
||||
await page.addInitScript(images => Object.assign(window, images), { before: png(100, 100, [240, 240, 240]), after: png(100, 100, [230, 230, 230]), ...images });
|
||||
await page.goto(`http://127.0.0.1:${vite.httpServer.address().port}/`);
|
||||
const outline = (side, index) => page.locator(`[data-side="${side}"] .visual-change-outline`).nth(index);
|
||||
await expect(outline("after", 0)).toBeVisible();
|
||||
@@ -143,3 +153,34 @@ test("A screen without hover keeps Before's outlines, as it cannot reveal one",
|
||||
await expect.poll(() => opacity(outline("before", 0))).toBe(1);
|
||||
await expect.poll(() => opacity(outline("before", 2))).toBe(1);
|
||||
});
|
||||
|
||||
test("Stepping never shows the screen before's pictures under the next one's outlines: a side still loading is an empty frame", { timeout: 30_000 }, async t => {
|
||||
const images = { before: png(100, 100, [200, 40, 40]), after: png(100, 100, [40, 40, 200]),
|
||||
nextBefore: "/__slow-before.png", nextAfter: png(100, 100, [200, 200, 40]) };
|
||||
const { page } = await openSplit(t, {}, images);
|
||||
for (const side of ["before", "after"]) await expect(page.locator(`[data-side="${side}"] img`)).toHaveAttribute("data-screenshot-state", "ready");
|
||||
// Every frame from the step on: the screen the outlines belong to, and any picture of the screen before still showing.
|
||||
await page.evaluate(previous => {
|
||||
window.stepFrames = [];
|
||||
const sample = () => {
|
||||
const outlines = document.querySelectorAll('[data-side="after"] .visual-change-outline').length;
|
||||
const stale = [...document.querySelectorAll(".compare-frame img")].filter(image => previous.includes(image.getAttribute("src"))
|
||||
&& Number(getComputedStyle(image).opacity) > 0).length;
|
||||
window.stepFrames.push({ outlines, stale });
|
||||
if (window.stepFrames.length < 30) requestAnimationFrame(sample);
|
||||
};
|
||||
requestAnimationFrame(sample);
|
||||
}, [images.before, images.after]);
|
||||
await page.keyboard.press("n");
|
||||
await expect.poll(() => page.evaluate(() => window.stepFrames.length)).toBe(30);
|
||||
const frames = await page.evaluate(() => window.stepFrames);
|
||||
assert.ok(frames.some(frame => frame.outlines === 1), "The step landed while the frames were sampled");
|
||||
assert.deepEqual(frames.filter(frame => frame.outlines === 1 && frame.stale > 0), [], "No frame showed a picture of the screen before under the next one's outlines");
|
||||
|
||||
// Before is still loading: its frame is empty, After's shows the new screen.
|
||||
const before = page.locator('[data-side="before"] img');
|
||||
await expect(before).toHaveAttribute("data-screenshot-state", "loading");
|
||||
await expect(before).toHaveCSS("opacity", "0");
|
||||
await expect(page.locator('[data-side="after"] img')).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expect(before).toHaveAttribute("data-screenshot-state", "ready", { timeout: 5000 });
|
||||
});
|
||||
@@ -5,11 +5,15 @@ import { chromium, expect } from "@playwright/test";
|
||||
import { PNG } from "pngjs";
|
||||
import { createBrowserVite } from "../helpers/browser-vite.mjs";
|
||||
|
||||
function png(width, height, color) {
|
||||
function pngBytes(width, height, color) {
|
||||
const image = new PNG({ width, height });
|
||||
for (let index = 0; index < image.data.length; index += 4) image.data.set([...color, 255], index);
|
||||
return `data:image/png;base64,${PNG.sync.write(image).toString("base64")}`;
|
||||
return PNG.sync.write(image);
|
||||
}
|
||||
const png = (width, height, color) => `data:image/png;base64,${pngBytes(width, height, color).toString("base64")}`;
|
||||
|
||||
const RED = [200, 40, 40];
|
||||
const BLUE = [40, 40, 200];
|
||||
|
||||
// A card that moved 40% of the width right: it is at 60% in After, so it was at 20% in Before.
|
||||
const entry = `
|
||||
@@ -19,11 +23,11 @@ import "/src/styles.css";
|
||||
const changes = [{ x: 60, y: 30, width: 30, height: 30, share: 100, regionCount: 1,
|
||||
move: { x: 40, y: 0, amount: { x: 400, y: 0 }, unit: "px" } }];
|
||||
createRoot(document.getElementById("root")).render(<div style={{ width: 400, display: "flex" }}>
|
||||
<SwipeCompare title="Share" before={window.before} after={window.after} imageAspect={1} changes={changes} position={50} />
|
||||
<SwipeCompare title="Share" before={window.before} after={window.after} imageAspect={1} changes={changes} position={window.position ?? 50} />
|
||||
</div>);
|
||||
`;
|
||||
|
||||
test("Swipe draws a moved area where its content was on Before's half and where it is on After's", { timeout: 30_000 }, async t => {
|
||||
async function openSwipe(t, images) {
|
||||
const vite = await createBrowserVite(t, {
|
||||
configFile: false, root: fileURLToPath(new URL("../../viewer", import.meta.url)),
|
||||
logLevel: "error", esbuild: { jsx: "automatic" },
|
||||
@@ -33,6 +37,12 @@ test("Swipe draws a moved area where its content was on Before's half and where
|
||||
load: id => id === "/__swipe-outlines.tsx" ? entry : undefined,
|
||||
configureServer(server) {
|
||||
server.middlewares.use((request, response, next) => {
|
||||
// A Before that takes a while to arrive.
|
||||
if (request.url === "/__slow-before.png") {
|
||||
response.setHeader("Content-Type", "image/png");
|
||||
setTimeout(() => response.end(pngBytes(100, 100, RED)), 1000);
|
||||
return;
|
||||
}
|
||||
if (new URL(request.url, "http://localhost").pathname !== "/") return next();
|
||||
response.setHeader("Content-Type", "text/html");
|
||||
response.end('<!doctype html><html><body style="margin:0"><div id="root"></div><script type="module" src="/__swipe-outlines.tsx"></script></body></html>');
|
||||
@@ -47,9 +57,23 @@ test("Swipe draws a moved area where its content was on Before's half and where
|
||||
const page = await browser.newPage({ viewport: { width: 600, height: 600 } });
|
||||
const errors = [];
|
||||
page.on("pageerror", error => errors.push(error.message));
|
||||
await page.addInitScript(images => Object.assign(window, images), { before: png(100, 100, [240, 240, 240]), after: png(100, 100, [230, 230, 230]) });
|
||||
t.after(() => assert.deepEqual(errors, []));
|
||||
await page.addInitScript(images => Object.assign(window, images), images);
|
||||
await page.goto(`http://127.0.0.1:${vite.httpServer.address().port}/`);
|
||||
return page;
|
||||
}
|
||||
|
||||
/** The colour on screen at `x` (a share of the frame's width), a fifth of the way down the Swipe frame, clear of the divider's handle. */
|
||||
async function colourAt(page, x) {
|
||||
const box = await page.locator(".visual-swipe").boundingBox();
|
||||
const shot = PNG.sync.read(await page.screenshot({ clip: { x: box.x + box.width * x, y: box.y + box.height / 5, width: 1, height: 1 } }));
|
||||
return [...shot.data.subarray(0, 3)];
|
||||
}
|
||||
|
||||
const near = (colour, expected) => colour.every((value, index) => Math.abs(value - expected[index]) <= 6);
|
||||
|
||||
test("Swipe draws a moved area where its content was on Before's half and where it is on After's", { timeout: 30_000 }, async t => {
|
||||
const page = await openSwipe(t, { before: png(100, 100, [240, 240, 240]), after: png(100, 100, [230, 230, 230]) });
|
||||
const frame = page.locator(".visual-swipe");
|
||||
const before = page.locator(".visual-swipe-outlines.before .visual-change-outline.moved");
|
||||
const after = page.locator(".visual-swipe-outlines.after .visual-change-outline.moved");
|
||||
@@ -60,5 +84,28 @@ test("Swipe draws a moved area where its content was on Before's half and where
|
||||
// Each side's outlines show only over its own half of the frame.
|
||||
const clips = await page.locator(".visual-swipe-outlines").evaluateAll(spans => spans.map(span => getComputedStyle(span).clipPath));
|
||||
assert.deepEqual(clips.map(clip => clip.startsWith("inset(")), [true, true]);
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
|
||||
test("Swipe never shows After on Before's half: while Before loads, its half is the empty frame", { timeout: 30_000 }, async t => {
|
||||
const page = await openSwipe(t, { before: "/__slow-before.png", after: png(100, 100, BLUE) });
|
||||
const before = page.locator("img.visual-swipe-before");
|
||||
await expect(page.locator("img.visual-swipe-after")).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await expect(before).toHaveAttribute("data-screenshot-state", "loading");
|
||||
await page.evaluate(() => document.getAnimations().forEach(animation => animation.finish()));
|
||||
assert.ok(near(await colourAt(page, 0.75), BLUE), "After shows on its own half");
|
||||
const waiting = await colourAt(page, 0.25);
|
||||
assert.ok(!near(waiting, BLUE) && !near(waiting, RED), `Before's half is the empty frame while Before loads: ${waiting}`);
|
||||
await expect(before).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await page.evaluate(() => document.getAnimations().forEach(animation => animation.finish()));
|
||||
assert.ok(near(await colourAt(page, 0.25), RED));
|
||||
assert.ok(near(await colourAt(page, 0.75), BLUE));
|
||||
});
|
||||
|
||||
for (const [position, shown] of [[0, BLUE], [100, RED]]) {
|
||||
test(`Swipe at ${position}% shows only ${position ? "Before" : "After"}, across the whole frame`, { timeout: 30_000 }, async t => {
|
||||
const page = await openSwipe(t, { before: png(100, 100, RED), after: png(100, 100, BLUE), position });
|
||||
for (const side of ["before", "after"]) await expect(page.locator(`img.visual-swipe-${side}`)).toHaveAttribute("data-screenshot-state", "ready");
|
||||
await page.evaluate(() => document.getAnimations().forEach(animation => animation.finish()));
|
||||
for (const x of [0.03, 0.5, 0.97]) assert.ok(near(await colourAt(page, x), shown), `${position}%: ${x} of the way across`);
|
||||
});
|
||||
}
|
||||
@@ -3576,6 +3576,13 @@ test("the Map's top right holds only fit, center and zoom; theme and full screen
|
||||
await expect.poll(() => viewport.getAttribute("style")).not.toBe(panned);
|
||||
await expect.poll(async () => scaleFromTransform(await viewport.getAttribute("style")))
|
||||
.toBeCloseTo(pannedScale, 6);
|
||||
// The flight to the centre dips the scale on its way, and a drag interrupts it where it is: let it
|
||||
// land first, the camera unchanged across two frames. The check above can pass on the flight's
|
||||
// first frame, before the dip shows.
|
||||
await expect.poll(() => viewport.evaluate((element) => new Promise<boolean>((resolve) => {
|
||||
const before = element.getAttribute("style");
|
||||
requestAnimationFrame(() => requestAnimationFrame(() => resolve(element.getAttribute("style") === before)));
|
||||
}))).toBe(true);
|
||||
|
||||
// The keyboard shortcut performs the same scale-preserving camera action.
|
||||
await page.mouse.move(panPoint.x, panPoint.y);
|
||||
@@ -4432,6 +4439,93 @@ test("pull-request comment deep links open the Changes filter and a surface's Di
|
||||
expect(new URL(page.url()).searchParams.get("workspace")).toBe(workspaceUrl);
|
||||
});
|
||||
|
||||
/**
|
||||
* Records, every frame, the route Compare names and the screenshots it shows: those at any opacity above nothing,
|
||||
* not on a hidden Flip side. An image still loading counts as the source it had before, which the browser keeps
|
||||
* painting until the new one is there. `staleCompareFrames` then checks each frame showed only its own screen's.
|
||||
*/
|
||||
async function sampleCompareFrames(page: Page, root: string) {
|
||||
await page.evaluate((root) => {
|
||||
const record = window as unknown as { compareFrames: { route: string; shown: string[] }[]; sampling: boolean };
|
||||
record.compareFrames = [];
|
||||
record.sampling = true;
|
||||
const sample = () => {
|
||||
const scope = document.querySelector(root);
|
||||
const route = scope?.querySelector(".compare-nav-route")?.textContent ?? "";
|
||||
const shown = [...(scope?.querySelectorAll<HTMLImageElement>(".compare-stage img") ?? [])]
|
||||
.filter((image) => Number(getComputedStyle(image).opacity) > 0 && getComputedStyle(image).visibility !== "hidden")
|
||||
.map((image) => image.complete && image.naturalWidth > 0 ? image.getAttribute("src") ?? "" : "(still loading)");
|
||||
record.compareFrames.push({ route, shown });
|
||||
if (record.sampling) requestAnimationFrame(sample);
|
||||
};
|
||||
requestAnimationFrame(sample);
|
||||
}, root);
|
||||
}
|
||||
|
||||
/** Every screenshot the stage holds for the route on show, once its pictures have loaded. */
|
||||
async function settledCompareScreen(page: Page, root: string) {
|
||||
const stage = page.locator(`${root} .compare-stage`);
|
||||
await expect(stage.locator("img[data-screenshot-state='loading']")).toHaveCount(0);
|
||||
return stage.evaluate((element, root) => ({
|
||||
route: document.querySelector(root)?.querySelector(".compare-nav-route")?.textContent ?? "",
|
||||
sources: [...element.querySelectorAll("img")].map((image) => image.getAttribute("src") ?? ""),
|
||||
}), root);
|
||||
}
|
||||
|
||||
/** The sampled frames in which a picture showed under a route it does not belong to. */
|
||||
async function staleCompareFrames(page: Page, screens: { route: string; sources: string[] }[]) {
|
||||
const frames = await page.evaluate(() => {
|
||||
const record = window as unknown as { compareFrames: { route: string; shown: string[] }[]; sampling: boolean };
|
||||
record.sampling = false;
|
||||
return record.compareFrames;
|
||||
});
|
||||
const sources = new Map<string, Set<string>>();
|
||||
for (const screen of screens) sources.set(screen.route, new Set([...(sources.get(screen.route) ?? []), ...screen.sources]));
|
||||
expect(new Set(frames.map((frame) => frame.route)).size, "The steps were sampled").toBeGreaterThan(1);
|
||||
return frames.filter((frame) => frame.shown.some((source) => !sources.get(frame.route)?.has(source)));
|
||||
}
|
||||
|
||||
test("a screenshot whose URL cannot be loaded shows No screenshot in its frame on the Map and in the Inspector", async ({ page }) => {
|
||||
await page.route((url) => url.pathname === "/api/artifacts/artifacts/area-0-screen-1-0.svg", (route) => route.fulfill({ status: 404, body: "" }));
|
||||
await page.goto("/map");
|
||||
const card = (title: string) => page.locator(".map-canvas .react-flow__node").filter({ hasText: title }).locator(".screen-node-image");
|
||||
const missing = card("/onboarding-step-2").locator(".image-placeholder");
|
||||
await expect(missing).toContainText("No screenshot");
|
||||
await expect(card("/onboarding-step-2").locator("img")).toHaveCount(0);
|
||||
// The placeholder takes the frame the screenshot would have had, like the screenshot beside it.
|
||||
const neighbour = card("/onboarding-step-1").locator("img");
|
||||
await expect(neighbour).toHaveAttribute("data-screenshot-state", "ready");
|
||||
const size = (locator: Locator) => locator.evaluate((element) => [element.offsetWidth, element.offsetHeight]);
|
||||
expect(await size(missing)).toEqual(await size(neighbour));
|
||||
await expect(card("/onboarding-step-2").locator(".screenshot-backing")).toHaveCSS("visibility", "hidden");
|
||||
|
||||
await page.locator(".map-canvas .react-flow__node").filter({ hasText: "/onboarding-step-2" }).locator(".screen-screenshot-target").click();
|
||||
await expect(page.locator(".right-panel .inspector-preview .screenshot-placeholder")).toContainText("No screenshot");
|
||||
});
|
||||
|
||||
test("stepping Compare by key or by its buttons never shows the screen before's pictures under the next one's name", async ({ page }) => {
|
||||
await page.setViewportSize({ width: 1440, height: 860 });
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/compare?screen=current-profile");
|
||||
const root = ".compare-section";
|
||||
const bar = page.locator(`${root} .compare-bar`);
|
||||
await expect(bar).toBeVisible();
|
||||
for (const mode of ["1", "2", "3"]) {
|
||||
await page.keyboard.press(mode);
|
||||
const screens = [await settledCompareScreen(page, root)];
|
||||
await sampleCompareFrames(page, root);
|
||||
await page.keyboard.press("ArrowRight");
|
||||
screens.push(await settledCompareScreen(page, root));
|
||||
await bar.getByRole("button", { name: "Previous changed screen" }).click();
|
||||
screens.push(await settledCompareScreen(page, root));
|
||||
await bar.getByRole("button", { name: "Next changed screen" }).click();
|
||||
screens.push(await settledCompareScreen(page, root));
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
screens.push(await settledCompareScreen(page, root));
|
||||
expect(await staleCompareFrames(page, screens), `Mode ${mode}`).toEqual([]);
|
||||
}
|
||||
});
|
||||
|
||||
test("desktop Compare: one command bar with the modes in it, even gaps to both bars", async ({ page }) => {
|
||||
await page.setViewportSize({ width: 1440, height: 860 });
|
||||
await serveWorkspace(page);
|
||||
@@ -4906,6 +5000,24 @@ test.describe("phone layout", () => {
|
||||
}
|
||||
});
|
||||
|
||||
test("stepping Compare from the header never shows the screen before's pictures under the next one's name", async ({ page }) => {
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/map");
|
||||
await page.getByRole("navigation", { name: "Views" }).getByRole("button", { name: /Compare/ }).tap();
|
||||
const root = ".phone-compare";
|
||||
const compare = page.locator(root);
|
||||
await expect(compare).toBeVisible();
|
||||
const next = compare.getByRole("button", { name: "Next changed screen" });
|
||||
const previous = compare.getByRole("button", { name: "Previous changed screen" });
|
||||
const screens = [await settledCompareScreen(page, root)];
|
||||
await sampleCompareFrames(page, root);
|
||||
for (const step of [next, next, previous]) {
|
||||
await step.tap();
|
||||
screens.push(await settledCompareScreen(page, root));
|
||||
}
|
||||
expect(await staleCompareFrames(page, screens)).toEqual([]);
|
||||
});
|
||||
|
||||
test("Compare is full screen, opens in Flip and steps from the header", async ({ page }) => {
|
||||
await serveWorkspace(page);
|
||||
await page.goto("/map");
|
||||
|
||||
@@ -60,6 +60,29 @@ test("ending a hold, or beginning another key, stops the first", (t) => {
|
||||
assert.equal(left, 2);
|
||||
});
|
||||
|
||||
test("a hold says when it ends, however it ends, and whether any key is held", (t) => {
|
||||
t.mock.timers.enable({ apis: ["setTimeout"] });
|
||||
const hold = createKeyHold();
|
||||
const ended = [];
|
||||
assert.ok(!hold.holding());
|
||||
hold.begin("ArrowRight", () => true, () => ended.push("released"));
|
||||
assert.ok(hold.holding());
|
||||
hold.release("ArrowLeft");
|
||||
assert.deepEqual(ended, [], "another key going up leaves it held");
|
||||
hold.release("ArrowRight");
|
||||
hold.begin("ArrowLeft", () => true, () => ended.push("replaced"));
|
||||
hold.begin("ArrowRight", () => true, () => ended.push("ended"));
|
||||
hold.end();
|
||||
let steps = 0;
|
||||
hold.begin("ArrowDown", () => (steps += 1) < 2, () => ended.push("at the end"));
|
||||
t.mock.timers.tick(HOLD_INITIAL_DELAY_MS);
|
||||
t.mock.timers.tick(holdIntervalMs(1));
|
||||
assert.deepEqual(ended, ["released", "replaced", "ended", "at the end"]);
|
||||
assert.ok(!hold.holding());
|
||||
hold.end();
|
||||
assert.equal(ended.length, 4, "an ended hold does not end again");
|
||||
});
|
||||
|
||||
test("another key ends a hold, as the OS's own repeat stops; its own repeats and a modifier do not", () => {
|
||||
const key = (code, key = code, repeat = false) => ({ code, key, repeat });
|
||||
const hold = createKeyHold();
|
||||
|
||||
@@ -29,6 +29,12 @@ export type ScreenScreenshotCardProps = {
|
||||
/** The frame of a screen without a screenshot: its run's screenshots, so it lines up beside them. */
|
||||
placeholderSize?: { width: number; height: number };
|
||||
loading?: "eager" | "lazy";
|
||||
/**
|
||||
* Frame the screenshot from behind while it loads and fades in, where the frame and its rings are drawn on the image
|
||||
* itself: the Map, and Screens on a phone. Screens' wells frame their own screenshots on wider windows. Only a
|
||||
* screenshot of recorded size has one.
|
||||
*/
|
||||
backing?: boolean;
|
||||
leading?: ReactNode;
|
||||
trailing?: ReactNode;
|
||||
/** Say "Open in Inspector" in a tooltip over the screenshot (Screens). The Map's cards go without. */
|
||||
@@ -47,13 +53,13 @@ export type ScreenScreenshotCardProps = {
|
||||
export function ScreenScreenshotCard(props: ScreenScreenshotCardProps) {
|
||||
// The placeholder takes the frame of the image it stands in for: a failed screenshot keeps the
|
||||
// frame it waited in, and a screen without one is framed like a phone screenshot beside it.
|
||||
const frame = props.screenshot && props.imageWidth && props.imageHeight
|
||||
? { width: props.imageWidth, height: props.imageHeight }
|
||||
const sized = Boolean(props.screenshot && props.imageWidth && props.imageHeight);
|
||||
const frame = sized
|
||||
? { width: props.imageWidth!, height: props.imageHeight! }
|
||||
: props.placeholderSize ?? DEFAULT_SCREENSHOT_SIZE;
|
||||
const frameStyle = { "--screenshot-width": frame.width, "--screenshot-height": frame.height } as CSSProperties;
|
||||
const missing = (
|
||||
<span
|
||||
className="image-placeholder"
|
||||
style={{ "--screenshot-width": frame.width, "--screenshot-height": frame.height } as CSSProperties}>
|
||||
<span className="image-placeholder" style={frameStyle}>
|
||||
<ImageOff aria-hidden="true" size={20} />
|
||||
No screenshot
|
||||
{props.missingReason ? <small className="image-placeholder-reason">{props.missingReason}</small> : null}
|
||||
@@ -104,6 +110,7 @@ export function ScreenScreenshotCard(props: ScreenScreenshotCardProps) {
|
||||
onClick={props.onClick}>
|
||||
<DiffFrame status={props.diff} accessibilityOnly={props.accessibilityOnly}>
|
||||
<span className={`screen-node-image${props.screenshot ? " has-screenshot" : " is-missing"}`}>
|
||||
{props.backing && sized ? <span className="screenshot-backing" style={frameStyle} aria-hidden="true" /> : null}
|
||||
{props.screenshot ? (
|
||||
<ScreenshotImage
|
||||
src={props.screenshot}
|
||||
@@ -114,7 +121,6 @@ export function ScreenScreenshotCard(props: ScreenScreenshotCardProps) {
|
||||
decoding="async"
|
||||
loading={props.loading ?? "lazy"}
|
||||
fallback={missing}
|
||||
holdPrevious
|
||||
/>
|
||||
) : missing}
|
||||
{/* On a phone's map, says what the second tap on the selected screen does. */}
|
||||
|
||||
@@ -327,13 +327,24 @@
|
||||
border-radius: 14px;
|
||||
background: var(--subtle);
|
||||
}
|
||||
.compare-frame > img {
|
||||
.compare-frame > img,
|
||||
.compare-flip-layer > img {
|
||||
display: block;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
object-fit: contain;
|
||||
}
|
||||
.compare-flip-frame { cursor: pointer; }
|
||||
/* Flip's two sides fill the frame, one over the other; the frame takes its size from its aspect ratio, not from them.
|
||||
The side off screen is hidden, spinner and all, and a flip shows it at once. */
|
||||
.compare-flip-layer {
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
}
|
||||
.compare-flip-layer[aria-hidden="true"] { visibility: hidden; }
|
||||
.compare-flip-frame:focus-visible { outline: 2px solid var(--accent); outline-offset: 3px; }
|
||||
.compare-swipe .visual-swipe { width: auto; height: var(--compare-frame-height); }
|
||||
|
||||
|
||||
@@ -9,6 +9,7 @@ import { formatShortcut, matchesShortcut, SHORTCUTS, shortcutsLive } from "../..
|
||||
import { createKeyHold, DIVIDER_GLIDE, glideWhileHeld, type KeyHold } from "../../utils/key-hold";
|
||||
import { optionalStorage } from "../../utils/embedded-report";
|
||||
import { usePhoneLayout } from "../../utils/phone-layout";
|
||||
import { useNeighborScreenshots } from "../../hooks/use-neighbor-screenshots";
|
||||
import { ToggleGroup } from "../shared/toggle-group";
|
||||
import { Tooltip } from "../shared/tooltip";
|
||||
import { DEFAULT_SCREENSHOT_RATIO, ScreenshotImage, ScreenshotPlaceholder } from "../shared/screenshot-image";
|
||||
@@ -133,7 +134,10 @@ export function useCompareController(options: CompareControllerOptions) {
|
||||
const mode: CompareMode = comparable ? (phone ? phoneMode : desktopMode) : "flip";
|
||||
const outlines = useOutlinesShown();
|
||||
const [activeArea, setActiveArea] = useState<number>();
|
||||
const [flipSide, setFlipSide] = useState<"before" | "after">("after");
|
||||
// Flip's side belongs to the screen it was chosen on: each screen starts on After, from its very
|
||||
// first render, so a step never shows the next screen's Before for a frame.
|
||||
const [flipped, setFlipped] = useState<{ screenId: string; side: "before" | "after" }>();
|
||||
const flipSide = flipped?.screenId === options.screenId ? flipped.side : "after";
|
||||
const [swipePosition, setSwipePosition] = useState(50);
|
||||
const [factsOpen, setFactsOpen] = useState(false);
|
||||
// The frame takes the recorded screenshot's shape at once, then the loaded image's (they agree
|
||||
@@ -150,10 +154,11 @@ export function useCompareController(options: CompareControllerOptions) {
|
||||
setLoadedAspect({ screenId: options.screenId, aspect: value });
|
||||
}, [options.screenId, hasAfter]);
|
||||
|
||||
// Each screen starts whole: no area selected, After showing, the facts closed.
|
||||
// Each screen starts whole: no area selected, After showing, the facts closed. A side flipped to on
|
||||
// another screen is already not this one's (above); it is dropped, so coming back starts on After.
|
||||
useEffect(() => {
|
||||
setActiveArea(undefined);
|
||||
setFlipSide("after");
|
||||
setFlipped(undefined);
|
||||
setFactsOpen(false);
|
||||
}, [options.screenId]);
|
||||
|
||||
@@ -171,7 +176,7 @@ export function useCompareController(options: CompareControllerOptions) {
|
||||
return Math.min(areas.length - 1, Math.max(0, current + step));
|
||||
});
|
||||
};
|
||||
const flip = () => setFlipSide((side) => (side === "after" ? "before" : "after"));
|
||||
const flip = () => setFlipped({ screenId: options.screenId, side: flipSide === "after" ? "before" : "after" });
|
||||
|
||||
const keyState = useRef({ previous, next, mode, activeArea, options, swipePosition });
|
||||
keyState.current = { previous, next, mode, activeArea, options, swipePosition };
|
||||
@@ -199,6 +204,17 @@ export function useCompareController(options: CompareControllerOptions) {
|
||||
holdRef.current ??= createKeyHold();
|
||||
const hold = holdRef.current;
|
||||
useEffect(() => hold.end, [hold]);
|
||||
// A held key steps faster than a screenshot fades in, so while it repeats each screen's pictures appear at once:
|
||||
// the stage is marked for ScreenshotImage directly, without a render of its own.
|
||||
const stageRef = useRef<HTMLDivElement>(null);
|
||||
const stepHeld = (direction: 1 | -1): boolean => {
|
||||
const stepped = stepScreen(direction);
|
||||
if (stepped) stageRef.current?.setAttribute("data-screenshot-instant", "");
|
||||
return stepped;
|
||||
};
|
||||
const endHeldSteps = () => stageRef.current?.removeAttribute("data-screenshot-instant");
|
||||
useNeighborScreenshots({ diff: options.diff, order: options.order, screenId: options.screenId,
|
||||
enabled: options.stepScreens !== false, hold });
|
||||
// A tap of [ or ] moves the divider one step; held, it keeps going from the same motion. The hold only
|
||||
// tracks the key; the glide reads it every frame and stops with it.
|
||||
const glideDivider = (code: string, direction: 1 | -1) => {
|
||||
@@ -215,9 +231,9 @@ export function useCompareController(options: CompareControllerOptions) {
|
||||
const keys = SHORTCUTS.compare;
|
||||
const stepScreens = state.options.stepScreens !== false;
|
||||
if (stepScreens && matchesShortcut(event, keys.previousScreen)) {
|
||||
if (stepScreen(-1)) hold.begin(event.code, () => stepScreen(-1));
|
||||
if (stepScreen(-1)) hold.begin(event.code, () => stepHeld(-1), endHeldSteps);
|
||||
} else if (stepScreens && matchesShortcut(event, keys.nextScreen)) {
|
||||
if (stepScreen(1)) hold.begin(event.code, () => stepScreen(1));
|
||||
if (stepScreen(1)) hold.begin(event.code, () => stepHeld(1), endHeldSteps);
|
||||
} else if (matchesShortcut(event, keys.nextArea)) {
|
||||
stepArea(1);
|
||||
} else if (matchesShortcut(event, keys.previousArea)) {
|
||||
@@ -279,7 +295,7 @@ export function useCompareController(options: CompareControllerOptions) {
|
||||
screen, screenDiff, route, position, previous, next, comparable, areas, facts, split, layoutShift, measurable,
|
||||
mode, chosenMode, modesDisabled, chooseMode, modeOptions, outlines, shownOutlines, statusBarIgnored, homeIndicatorIgnored, systemRegions, toggleOutlines,
|
||||
activeArea, setActiveArea, stepArea, flipSide, flip, swipePosition, setSwipePosition,
|
||||
aspect, setAspect, factsOpen, setFactsOpen,
|
||||
aspect, setAspect, factsOpen, setFactsOpen, stageRef,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -393,7 +409,7 @@ export function CompareSection(props: CompareSectionProps) {
|
||||
</div>
|
||||
</header>
|
||||
|
||||
<div className={`compare-stage mode-${mode}`}>
|
||||
<div ref={compare.stageRef} className={`compare-stage mode-${mode}`}>
|
||||
{/* Every mode names Before and After in a row above the screenshots. */}
|
||||
<CompareStage
|
||||
mode={mode}
|
||||
@@ -472,6 +488,21 @@ export function CompareStage(props: StageProps) {
|
||||
// An outline taken out from under the pointer reports no leave, so another screen, mode or outline
|
||||
// toggle drops the hover rather than lighting an area the pointer is not on.
|
||||
useLayoutEffect(() => setHoverIndex(undefined), [props.areas, props.mode, props.showOutlines]);
|
||||
// Flip keeps both sides mounted, so flipping is an instant swap of two decoded pictures. The side off screen mounts
|
||||
// once the side on screen is ready for this pair of screenshots, or on the first flip to it, so a held key stepping
|
||||
// through Flip reads one side of each screen it passes, not two.
|
||||
const pair = `${before ?? ""} ${after ?? ""}`;
|
||||
const [flipPair, setFlipPair] = useState<string>();
|
||||
const flipBoth = flipPair === pair;
|
||||
if (props.mode === "flip" && props.flipSide === "before" && flipPair !== pair) setFlipPair(pair);
|
||||
// The side on screen loads (CompareImage reports it), or a step kept its screenshot (the same After beside another
|
||||
// Before), which fires no load: it is ready as it is.
|
||||
const flipFrameRef = useRef<HTMLButtonElement>(null);
|
||||
useLayoutEffect(() => {
|
||||
if (props.mode !== "flip" || flipPair === pair) return;
|
||||
const shown = flipFrameRef.current?.querySelector(`.compare-flip-layer[data-side="${props.flipSide}"] img`);
|
||||
if (shown?.getAttribute("data-screenshot-state") === "ready") setFlipPair(pair);
|
||||
}, [props.mode, props.flipSide, flipPair, pair]);
|
||||
if (!before && !after) {
|
||||
const reason = diff.captureNotes?.after ?? diff.captureNotes?.before;
|
||||
return (
|
||||
@@ -515,6 +546,7 @@ export function CompareStage(props: StageProps) {
|
||||
}
|
||||
if (props.mode === "flip" && before && after) {
|
||||
const showing = props.flipSide;
|
||||
const sides = (["before", "after"] as const).filter((side) => side === showing || flipBoth);
|
||||
return (
|
||||
<figure className="compare-side">
|
||||
{/* Both names, with the one on screen lit; the other one flips to it. */}
|
||||
@@ -527,10 +559,21 @@ export function CompareStage(props: StageProps) {
|
||||
))}
|
||||
</figcaption>
|
||||
<div className="compare-frame-wrap">
|
||||
<button type="button" className="compare-frame compare-flip-frame" data-side={showing}
|
||||
<button ref={flipFrameRef} type="button" className="compare-frame compare-flip-frame" data-side={showing}
|
||||
aria-label={`Show ${showing === "after" ? "Before" : "After"}`} onClick={props.onFlip}>
|
||||
<CompareImage src={showing === "after" ? after : before} alt={`${props.title}, ${showing}`}
|
||||
placeholder="No screenshot" side={showing} onAspect={props.onAspect} />
|
||||
{/* Each side is a layer of its own, with its spinner and its no-screenshot state; the one off screen
|
||||
is hidden, and its pictures land without a fade, so a flip shows the other side at once. */}
|
||||
{sides.map((side) => (
|
||||
<span key={side} className="compare-flip-layer" data-side={side}
|
||||
{...(side === showing ? {} : { "aria-hidden": true, "data-screenshot-instant": "" })}>
|
||||
<CompareImage src={side === "after" ? after : before} alt={`${props.title}, ${side}`}
|
||||
placeholder="No screenshot" side={side}
|
||||
onAspect={(aspect, loaded) => {
|
||||
if (loaded === showing) setFlipPair(pair);
|
||||
props.onAspect(aspect, loaded);
|
||||
}} />
|
||||
</span>
|
||||
))}
|
||||
{props.overlay}
|
||||
</button>
|
||||
</div>
|
||||
|
||||
@@ -109,7 +109,10 @@
|
||||
object-fit: cover;
|
||||
pointer-events: none;
|
||||
}
|
||||
/* Each side shows only its own half of the frame, so a side still loading leaves its half empty
|
||||
instead of showing the other side's picture there. */
|
||||
.visual-swipe-before { clip-path: inset(0 calc(100% - var(--swipe-position)) 0 0); }
|
||||
.visual-swipe-after { clip-path: inset(0 0 0 var(--swipe-position)); }
|
||||
/* With a moved area, each side's outlines over its own half (see ChangeOutlines). */
|
||||
.visual-swipe-outlines { position: absolute; z-index: 1; inset: 0; pointer-events: none; }
|
||||
.visual-swipe-outlines.before { --outline-before: 1; clip-path: inset(0 calc(100% - var(--swipe-position)) 0 0); }
|
||||
|
||||
@@ -94,7 +94,7 @@ export function PhoneCompare(props: CompareControllerOptions & {
|
||||
/>
|
||||
</div>
|
||||
|
||||
<div className={`compare-stage phone-compare-stage mode-${mode}`}
|
||||
<div ref={compare.stageRef} className={`compare-stage phone-compare-stage mode-${mode}`}
|
||||
style={{ "--compare-aspect": compare.aspect } as CSSProperties}
|
||||
onPointerDownCapture={(event) => { pressed.current = { x: event.clientX, y: event.clientY }; }}
|
||||
onClickCapture={stepFromEdge}>
|
||||
|
||||
@@ -562,7 +562,7 @@
|
||||
/* A screen without a screenshot: on the Map the placeholder is sized by its slot's height, which a
|
||||
Screens grid cell does not have. Here it takes the cell's width and a screenshot's proportions,
|
||||
so it lines up with the screenshots beside it. */
|
||||
.screens-cell .screen-node-image:has(> .image-placeholder) { container-type: normal; }
|
||||
.screens-cell .screen-node-image:has(> :is(.image-placeholder, .screenshot-backing)) { container-type: normal; }
|
||||
.screens-cell .screen-node-image > .image-placeholder {
|
||||
/* Like the image beside it: the screenshot's proportions inside the frame's 1px border. */
|
||||
box-sizing: content-box;
|
||||
@@ -571,6 +571,13 @@
|
||||
aspect-ratio: var(--screenshot-width) / var(--screenshot-height);
|
||||
font-size: var(--phone-caption-size, 12px);
|
||||
}
|
||||
/* A screenshot's backing fills the image box exactly: the image sets the cell's height from its own
|
||||
proportions, and the backing draws its frame there while it loads. */
|
||||
.screens-cell .screen-node-image > .screenshot-backing {
|
||||
box-sizing: border-box;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
}
|
||||
|
||||
/* Pinch and double-tap zoom the page on a phone; only the map canvas zooms, and it handles that itself. */
|
||||
.phone-layout { touch-action: pan-x pan-y; }
|
||||
|
||||
@@ -64,7 +64,10 @@
|
||||
.image-lightbox-step:disabled { opacity: 0.3; cursor: default; }
|
||||
.image-lightbox-close:focus-visible,
|
||||
.image-lightbox-step:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
|
||||
/* The image is all the stage shows, and it is hidden while it loads: the spinner centres in the
|
||||
stage meanwhile, in the bar's light text colour. */
|
||||
.image-lightbox-stage {
|
||||
position: relative;
|
||||
display: flex;
|
||||
min-height: 0;
|
||||
flex: 1;
|
||||
@@ -82,3 +85,4 @@
|
||||
object-fit: contain;
|
||||
box-shadow: 0 20px 60px rgb(0 0 0 / 0.5);
|
||||
}
|
||||
.image-lightbox-stage > .screenshot-loading { color: rgb(237 238 240 / 0.6); }
|
||||
@@ -58,7 +58,7 @@ export function ImageLightbox(props: { images: readonly LightboxImage[]; initial
|
||||
<ChevronLeft aria-hidden="true" />
|
||||
</button>
|
||||
) : null}
|
||||
<ScreenshotImage key={image.src} src={image.src} alt={image.alt} loading="eager" draggable={false} />
|
||||
<ScreenshotImage key={image.src} src={image.src} alt={image.alt} loading="eager" indicator="spinner" draggable={false} />
|
||||
{multiple ? (
|
||||
<button type="button" className="image-lightbox-step" aria-label="Next image"
|
||||
disabled={index === props.images.length - 1} onClick={() => move(1)}>
|
||||
|
||||
@@ -10,16 +10,21 @@ export const DEFAULT_SCREENSHOT_SIZE = { width: 390, height: Math.round(390 / DE
|
||||
type ScreenshotImageProps = ImgHTMLAttributes<HTMLImageElement> & {
|
||||
/** Large previews centre a spinner while an embedded screenshot resolves; small images wait as a quiet empty frame. */
|
||||
indicator?: "spinner";
|
||||
/** Stands in for an embedded screenshot that cannot be read: the caller's own no-screenshot state. */
|
||||
/** Stands in for a screenshot that cannot be read or loaded: the caller's own no-screenshot state. */
|
||||
fallback?: ReactNode;
|
||||
/**
|
||||
* Keeps the picture of the source before on screen until the new one has decoded: for a map card, whose source
|
||||
* changes only when the report's other appearance or target swaps every screenshot at once. Never for a view that
|
||||
* steps between screens or draws changes over the picture, where it would show the screen before under the new one.
|
||||
* Keeps the picture of the source before on screen until the new one has decoded, and shows the new one without a
|
||||
* fade: for the app icon, which changes only when another target's report is shown and should not blink. Never for a
|
||||
* screenshot. A view that steps between screens or draws changes over the picture would show the screen before under
|
||||
* the new one, and a card would show the other target's or appearance's capture as this one's: a screenshot goes
|
||||
* blank while its replacement loads.
|
||||
*/
|
||||
holdPrevious?: boolean;
|
||||
};
|
||||
|
||||
/** How long a loaded screenshot waits for its decode before it is shown anyway. */
|
||||
const DECODE_WAIT_MS = 300;
|
||||
|
||||
type ScreenshotState = "loading" | "ready" | "failed";
|
||||
|
||||
function dimension(value: number | string | undefined): number | undefined {
|
||||
@@ -38,16 +43,45 @@ function waitingSource(width: number | string | undefined, height: number | stri
|
||||
return `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='${w}' height='${h}'/%3E`;
|
||||
}
|
||||
|
||||
/** The picture each image is waiting to decode, so a load and a re-render waiting for the same one share a wait. */
|
||||
const decodeWaits = new WeakMap<HTMLImageElement, string>();
|
||||
|
||||
/**
|
||||
* Decode embedded evidence near the viewport; ordinary image URLs keep native loading. While an
|
||||
* embedded screenshot resolves, the image shows an empty frame (and, with `indicator`, a spinner)
|
||||
* and never its alt text; a screenshot that cannot be read shows `fallback`.
|
||||
* Calls `show` once `image` has decoded `picture`, so the picture fades in on its own pixels rather than on an empty
|
||||
* box its decode fills in partway; one whose decode does not settle soon is shown anyway. A rejected decode is a
|
||||
* broken image, whose error event follows, or a source replaced meanwhile, which is shown on its own load. One wait
|
||||
* runs per image and picture: a second call while it runs adds nothing.
|
||||
*/
|
||||
function whenDecoded(image: HTMLImageElement, picture: string, show: () => void) {
|
||||
if (decodeWaits.get(image) === picture) return;
|
||||
decodeWaits.set(image, picture);
|
||||
let settled = false;
|
||||
const settle = (shown: boolean) => {
|
||||
if (settled) return;
|
||||
settled = true;
|
||||
clearTimeout(timer);
|
||||
if (decodeWaits.get(image) === picture) decodeWaits.delete(image);
|
||||
if (shown && image.isConnected && image.getAttribute("src") === picture) show();
|
||||
};
|
||||
const timer = setTimeout(() => settle(true), DECODE_WAIT_MS);
|
||||
image.decode().then(() => settle(true), () => settle(image.complete && image.naturalWidth > 0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode embedded evidence near the viewport; ordinary image URLs keep native loading. While a
|
||||
* screenshot loads, the image is hidden over its frame (an embedded one keeps its size and, with
|
||||
* `indicator`, shows a spinner) and never shows its alt text or the picture of the source before;
|
||||
* a screenshot that cannot be read or loaded shows `fallback`. A picture that fills an empty frame
|
||||
* fades in, unless it lands inside `[data-screenshot-instant]` (Compare stepping under a held key,
|
||||
* Flip's hidden side), where it appears at once.
|
||||
*/
|
||||
export function ScreenshotImage({ src, loading, indicator, fallback, holdPrevious, onLoad, onError, ...props }: ScreenshotImageProps) {
|
||||
const imageRef = useRef<HTMLImageElement>(null);
|
||||
const [resolved, setResolved] = useState<{ source: string; url: string }>();
|
||||
const [failed, setFailed] = useState<string>();
|
||||
const [shown, setShown] = useState<string>();
|
||||
// The picture shown, when it fades in: it filled an empty frame outside an instant stage.
|
||||
const [revealed, setRevealed] = useState<string>();
|
||||
const [lastSource, setLastSource] = useState(src);
|
||||
// With `holdPrevious`, the picture of the source before, kept on screen until the new one has decoded.
|
||||
const [held, setHeld] = useState<string>();
|
||||
@@ -60,6 +94,7 @@ export function ScreenshotImage({ src, loading, indicator, fallback, holdPreviou
|
||||
setHeld(holdPrevious && failed !== lastSource ? shown ?? held : undefined);
|
||||
setResolved(undefined);
|
||||
setShown(undefined);
|
||||
setRevealed(undefined);
|
||||
setFailed(undefined);
|
||||
}
|
||||
|
||||
@@ -122,39 +157,56 @@ export function ScreenshotImage({ src, loading, indicator, fallback, holdPreviou
|
||||
};
|
||||
}, [embedded, src, loading]);
|
||||
|
||||
const url = embedded && resolved?.source === src ? resolved.url : undefined;
|
||||
// An ordinary URL is its own picture; an embedded one is the URL its report resolved it to.
|
||||
const url = !embedded ? src : resolved?.source === src ? resolved.url : undefined;
|
||||
const state: ScreenshotState = failed === src ? "failed" : url && shown === url ? "ready" : "loading";
|
||||
const displayed = state !== "failed" ? url ?? held : undefined;
|
||||
// Shown once decoded. Replacing a held picture is no reveal: it stays up until the new one is there.
|
||||
const show = (image: HTMLImageElement, picture: string) => whenDecoded(image, picture, () => {
|
||||
setShown(picture);
|
||||
setRevealed(held || image.closest("[data-screenshot-instant]") ? undefined : picture);
|
||||
setHeld(undefined);
|
||||
});
|
||||
|
||||
// Re-committing the URL the image already shows (it left the viewport and came back before a
|
||||
// render, and the report still held the URL) fires no load event: the decoded image is ready.
|
||||
// render, and the report still held the URL) fires no load event: the loaded image is shown once
|
||||
// its decode settles, as a load would show it.
|
||||
useLayoutEffect(() => {
|
||||
const image = imageRef.current;
|
||||
if (!displayed || displayed !== url || shown === displayed || !image || image.getAttribute("src") !== displayed) return;
|
||||
if (image.complete && image.naturalWidth > 0) {
|
||||
setShown(displayed);
|
||||
setHeld(undefined);
|
||||
}
|
||||
}, [displayed, url, shown]);
|
||||
if (image.complete && image.naturalWidth > 0) show(image, displayed);
|
||||
});
|
||||
|
||||
if (!embedded) return <img {...props} ref={imageRef} loading={loading} src={src} onLoad={onLoad} onError={onError} />;
|
||||
if (state === "failed" && fallback !== undefined) return <>{fallback}</>;
|
||||
// The caller hears the screenshot's own load and error events and a failed resolve (dispatched
|
||||
// above, so untrusted), never the stand-in's.
|
||||
const isScreenshot = (event: SyntheticEvent<HTMLImageElement>) => Boolean(url) && event.currentTarget.getAttribute("src") === url;
|
||||
const status = {
|
||||
"data-screenshot-state": state,
|
||||
// A held picture stays shown while the new one loads; every other waiting image is hidden at once.
|
||||
"data-screenshot-held": state === "loading" && held ? "" : undefined,
|
||||
"data-screenshot-reveal": state === "ready" && revealed === url ? "" : undefined,
|
||||
onLoad: (event: SyntheticEvent<HTMLImageElement>) => {
|
||||
if (!isScreenshot(event)) return;
|
||||
show(event.currentTarget, url!);
|
||||
onLoad?.(event);
|
||||
},
|
||||
};
|
||||
// An ordinary URL loads natively. Each source is an image of its own, so the browser never paints the picture of
|
||||
// the source before while the new one loads; a held one keeps its element, which keeps painting it.
|
||||
if (!embedded) {
|
||||
return <img key={holdPrevious ? undefined : src} {...props} {...status} ref={imageRef} loading={loading} src={src}
|
||||
onError={event => {
|
||||
if (event.currentTarget.getAttribute("src") === src) { setFailed(src); setHeld(undefined); }
|
||||
onError?.(event);
|
||||
}} />;
|
||||
}
|
||||
return (
|
||||
<>
|
||||
<img {...props} ref={imageRef} loading={loading}
|
||||
<img {...props} {...status} ref={imageRef} loading={loading}
|
||||
src={displayed ?? waitingSource(props.width, props.height)}
|
||||
data-screenshot-src={src}
|
||||
data-screenshot-state={state}
|
||||
aria-busy={state === "loading" || undefined}
|
||||
onLoad={event => {
|
||||
if (!isScreenshot(event)) return;
|
||||
setShown(url);
|
||||
setHeld(undefined);
|
||||
onLoad?.(event);
|
||||
}}
|
||||
onError={event => {
|
||||
if (event.nativeEvent.isTrusted) {
|
||||
// The held picture's URL was revoked since (the report let it go): nothing to show until the new one.
|
||||
|
||||
@@ -157,6 +157,8 @@ function ScreenCell(props: {
|
||||
dimmed: boolean;
|
||||
/** The run's screenshot shape, which a screen without a screenshot is framed in. */
|
||||
typicalSize?: ScreenshotSize | undefined;
|
||||
/** A phone's cell, whose screenshot is its own frame: no well frames it while it loads. */
|
||||
phone?: boolean | undefined;
|
||||
onSelect: () => void;
|
||||
}) {
|
||||
const artifact = primaryScreenshotForScreen(props.screen, props.index);
|
||||
@@ -179,6 +181,7 @@ function ScreenCell(props: {
|
||||
selected={props.selected}
|
||||
ariaPressed={props.selected}
|
||||
loading="lazy"
|
||||
backing={props.phone === true}
|
||||
onClick={props.onSelect}
|
||||
{...(props.via || props.elsewhere?.length ? { note: <>
|
||||
{props.via ? <span className="screens-cell-via">via “{props.via}”</span> : null}
|
||||
@@ -578,6 +581,7 @@ export function ScreensView(props: ScreensViewProps) {
|
||||
elsewhere={isChanged(props.diff, id) ? undefined : props.changedElsewhere?.get(id)}
|
||||
via={tree.via.get(id)}
|
||||
typicalSize={typicalSize}
|
||||
phone={props.phone}
|
||||
selected={props.selectedScreenId === id}
|
||||
dimmed={Boolean(props.focus?.length) && !props.focus!.some((state) => state === focusStatusOf(props.diff?.screens.get(id)))}
|
||||
onSelect={() => props.onSelectScreen(id)} />
|
||||
|
||||
@@ -117,6 +117,7 @@ function ScreenNodeCard({ data, selected }: NodeProps<ScreenGraphNode>) {
|
||||
imageHeight={data.screenshotSize?.imageHeight ?? data.frame.screen.height}
|
||||
placeholderSize={data.frame.screen}
|
||||
loading="lazy"
|
||||
backing
|
||||
// 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" />}
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
import { useEffect, useRef } from "react";
|
||||
import type { BuildDiff } from "../utils/build-diff";
|
||||
import type { ChangedScreen } from "../utils/changed-screens";
|
||||
import { isEmbeddedArtifactUrl, leaseEmbeddedArtifactUrl } from "../utils/embedded-report";
|
||||
import type { KeyHold } from "../utils/key-hold";
|
||||
|
||||
/** How long Compare rests on a screen before it reads the next one's screenshots. */
|
||||
export const NEIGHBOR_SETTLE_MS = 250;
|
||||
|
||||
export type NeighborScreenshotsOptions = {
|
||||
diff: BuildDiff;
|
||||
order: readonly ChangedScreen[];
|
||||
screenId: string;
|
||||
/** Compare steps between screens; the Inspector, which stays on its screen, reads no neighbour. */
|
||||
enabled: boolean;
|
||||
/** The keys that step: no neighbour is read while one is held. */
|
||||
hold: KeyHold;
|
||||
};
|
||||
|
||||
/**
|
||||
* Reads the screenshots of the screen Compare would step to next, in the direction it last stepped (by key, the
|
||||
* header's buttons, a tap or the picker), once it has rested on a screen. The next step usually finds them decoded,
|
||||
* so its pictures fade in within a frame of the step. Each is one use of the report's screenshot until Compare moves
|
||||
* on, then released; nothing is decoded outside the page's own images.
|
||||
*
|
||||
* A held key steps past screens faster than they could be read, so nothing is read until it is released. The reads
|
||||
* are the report's prefetches: one starts only while two slots stay free for the step the reviewer takes, so
|
||||
* speculative work never holds more than two, whatever earlier prefetches are still reading, and one that has not
|
||||
* started when Compare moves on is dropped unread.
|
||||
*/
|
||||
export function useNeighborScreenshots({ diff, order, screenId, enabled, hold }: NeighborScreenshotsOptions) {
|
||||
const position = order.findIndex((entry) => entry.id === screenId);
|
||||
const last = useRef<{ position: number; direction: 1 | -1 }>({ position, direction: 1 });
|
||||
useEffect(() => {
|
||||
if (!enabled || position < 0) return;
|
||||
const previous = last.current;
|
||||
const direction = position === previous.position ? previous.direction : position > previous.position ? 1 : -1;
|
||||
last.current = { position, direction };
|
||||
const neighbor = order[position + direction];
|
||||
const screen = neighbor ? diff.screens.get(neighbor.id) : undefined;
|
||||
const sources = new Set([screen?.beforeScreenshot, screen?.afterScreenshot]
|
||||
.filter((source): source is string => Boolean(source && isEmbeddedArtifactUrl(source))));
|
||||
if (sources.size === 0) return;
|
||||
const leases: { release: () => boolean; held: boolean }[] = [];
|
||||
let timer: ReturnType<typeof setTimeout>;
|
||||
const read = () => {
|
||||
if (hold.holding()) {
|
||||
timer = setTimeout(read, NEIGHBOR_SETTLE_MS);
|
||||
return;
|
||||
}
|
||||
for (const source of sources) {
|
||||
const leased = leaseEmbeddedArtifactUrl(source, "prefetch");
|
||||
const lease = { release: leased.release, held: true };
|
||||
leases.push(lease);
|
||||
// A read that failed (a report switched away from, or a prefetch dropped) holds nothing to release.
|
||||
void leased.url.catch(() => { lease.held = false; });
|
||||
}
|
||||
};
|
||||
timer = setTimeout(read, NEIGHBOR_SETTLE_MS);
|
||||
return () => {
|
||||
clearTimeout(timer);
|
||||
for (const lease of leases) if (lease.held) lease.release();
|
||||
};
|
||||
}, [enabled, position, order, diff, hold]);
|
||||
}
|
||||
+57
-11
@@ -154,6 +154,8 @@
|
||||
/* The bottom bar resizes with the same timing as the canvas it switches. */
|
||||
--toolbar-motion: 220ms;
|
||||
--toolbar-easing: ease-in-out;
|
||||
/* A screenshot fades in over its empty frame once its pixels are decoded. */
|
||||
--screenshot-reveal: 160ms;
|
||||
}
|
||||
|
||||
:root[data-theme="dark"] {
|
||||
@@ -634,9 +636,10 @@ code {
|
||||
/* A screen without a screenshot, or whose screenshot could not be read, frames its placeholder
|
||||
where an image of --screenshot-width x --screenshot-height would sit under the rules above:
|
||||
contained in the slot inside its border, never enlarged. It lines up with the screenshots
|
||||
beside it, and a failed screenshot keeps the frame it waited in. */
|
||||
.screen-node-image:has(> .image-placeholder) { container-type: size; }
|
||||
.screen-node-image > .image-placeholder {
|
||||
beside it, and a failed screenshot keeps the frame it waited in. A Map card's screenshot waits
|
||||
over a backing of the same frame (below; a phone's Screens cell sizes it in phone.css). */
|
||||
.screen-node-image:has(> :is(.image-placeholder, .screenshot-backing)) { container-type: size; }
|
||||
.screen-node-image > :is(.image-placeholder, .screenshot-backing) {
|
||||
--frame-border: 1px;
|
||||
display: flex;
|
||||
box-sizing: content-box;
|
||||
@@ -670,8 +673,28 @@ code {
|
||||
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,
|
||||
.screen-screenshot-card.selected .screen-node-image > .image-placeholder { border-color: var(--accent); box-shadow: 0 0 0 2px var(--accent); }
|
||||
.screen-node-image:hover > :is(.image-placeholder, .screenshot-backing),
|
||||
.screen-screenshot-card.selected .screen-node-image > :is(.image-placeholder, .screenshot-backing) { border-color: var(--accent); box-shadow: 0 0 0 2px var(--accent); }
|
||||
/* A Map card, and a Screens card on a phone, draws its frame (fill, border, status and rings) on
|
||||
the image itself, which is hidden while it loads. The backing draws the same frame under it, in
|
||||
the image's geometry, while the image waits and while it fades in, so the frame and its rings
|
||||
hold steady; then it hides. The fading image leaves its rings to the backing, so their soft lift
|
||||
is not drawn twice, and takes them back in the frame the backing hides. */
|
||||
.screen-node-image > .screenshot-backing {
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
margin: auto;
|
||||
pointer-events: none;
|
||||
visibility: hidden;
|
||||
}
|
||||
.screen-node-image:has(> .screenshot-backing) > img { position: relative; }
|
||||
.screen-node-image:has(> img[data-screenshot-state="loading"]) > .screenshot-backing { visibility: visible; }
|
||||
.screen-node-image:has(> img[data-screenshot-reveal]) > .screenshot-backing { animation: screenshot-backing var(--screenshot-reveal) step-end; }
|
||||
.screen-node-image:has(> .screenshot-backing) > img[data-screenshot-reveal] {
|
||||
animation: screenshot-reveal var(--screenshot-reveal) ease-out, screenshot-backed var(--screenshot-reveal) step-end;
|
||||
}
|
||||
@keyframes screenshot-backing { from, to { visibility: visible; } }
|
||||
@keyframes screenshot-backed { from, to { box-shadow: none; } }
|
||||
.canvas-active-frame {
|
||||
position: relative;
|
||||
display: block;
|
||||
@@ -726,11 +749,11 @@ code {
|
||||
--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) {
|
||||
.map-surface .screen-screenshot-card .screen-node-image :is(img, .image-placeholder, .screenshot-backing) {
|
||||
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) {
|
||||
.map-surface .react-flow__node-screen:is(.selected, .graph-node-hover-subject) .screen-screenshot-card .screen-node-image :is(img, .image-placeholder, .screenshot-backing) {
|
||||
box-shadow:
|
||||
0 0 0 var(--ring-status) var(--diff, transparent),
|
||||
0 0 0 calc(var(--ring-status) + 4 * var(--ring-unit)) var(--screen),
|
||||
@@ -1348,12 +1371,17 @@ code {
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
}
|
||||
/* The frame holds the fill, so a screenshot that is hidden while it loads leaves its frame in place.
|
||||
Nothing clips to it: an outline's ring and measurement may cross the frame's edge. */
|
||||
.inspector-diff-preview:has(> img) {
|
||||
border-radius: 9px;
|
||||
background: var(--subtle);
|
||||
}
|
||||
.inspector-diff-preview img {
|
||||
display: block;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
border-radius: 9px;
|
||||
background: var(--subtle);
|
||||
object-fit: cover;
|
||||
}
|
||||
/* The frame line is drawn over the screenshot's edge, not inside its box, so the image fills
|
||||
@@ -1700,9 +1728,9 @@ code {
|
||||
border-color: var(--diff);
|
||||
box-shadow: 0 0 0 2px var(--diff);
|
||||
}
|
||||
.screen-screenshot-card .diff-frame.diff-added .screen-node-image > .image-placeholder,
|
||||
.screen-screenshot-card .diff-frame.diff-modified .screen-node-image > .image-placeholder,
|
||||
.screen-screenshot-card .diff-frame.diff-removed .screen-node-image > .image-placeholder {
|
||||
.screen-screenshot-card .diff-frame.diff-added .screen-node-image > :is(.image-placeholder, .screenshot-backing),
|
||||
.screen-screenshot-card .diff-frame.diff-modified .screen-node-image > :is(.image-placeholder, .screenshot-backing),
|
||||
.screen-screenshot-card .diff-frame.diff-removed .screen-node-image > :is(.image-placeholder, .screenshot-backing) {
|
||||
border-color: var(--diff);
|
||||
box-shadow: 0 0 0 2px var(--diff);
|
||||
}
|
||||
@@ -1779,6 +1807,24 @@ code {
|
||||
@media (prefers-reduced-motion: reduce) {
|
||||
.screenshot-loading > svg { animation: none; }
|
||||
}
|
||||
/* A screenshot that is loading or could not be read is hidden at once, in the same frame as its
|
||||
new source, so no view paints the picture of the source before (the browser keeps painting it
|
||||
until the new one loads) under a new screen's name or outlines; its frame stays. Hiding never
|
||||
fades, and outranks a view's own image opacity, such as a dimmed variant thumbnail's. A held
|
||||
picture (the app icon) stays shown until the new one is there. */
|
||||
:root img:is([data-screenshot-state="loading"]:not([data-screenshot-held]), [data-screenshot-state="failed"]) {
|
||||
opacity: 0;
|
||||
transition: none;
|
||||
}
|
||||
/* A picture that fills an empty frame fades in. An animation, not a transition: the image can be
|
||||
ready before its first paint, and it keeps a view's own resting opacity. */
|
||||
img[data-screenshot-reveal] { animation: screenshot-reveal var(--screenshot-reveal) ease-out; }
|
||||
@keyframes screenshot-reveal { from { opacity: 0; } }
|
||||
@media (prefers-reduced-motion: reduce) {
|
||||
img[data-screenshot-reveal],
|
||||
.screen-node-image:has(> .screenshot-backing) > img[data-screenshot-reveal],
|
||||
.screen-node-image:has(> img[data-screenshot-reveal]) > .screenshot-backing { animation: none; }
|
||||
}
|
||||
.status-badge { display: inline-flex; align-items: center; width: fit-content; padding: 4px 7px; border-radius: 6px; color: var(--secondary); background: var(--element); font-size: 10px; font-weight: 500; line-height: 1.2; text-transform: capitalize; }
|
||||
.status-badge.info { color: var(--accent-strong); background: var(--accent-soft); }
|
||||
.status-badge.success { color: var(--success); background: var(--success-soft); }
|
||||
|
||||
@@ -266,8 +266,12 @@ function validateManifest(value: unknown): PreviewManifest {
|
||||
}
|
||||
return manifest;
|
||||
}
|
||||
/** Eager screenshots (the Inspector's) are decoded before lazy ones (canvas nodes and thumbnails). */
|
||||
export type ScreenshotPriority = "eager" | "lazy";
|
||||
/**
|
||||
* Eager screenshots (the Inspector's) are decoded before lazy ones (canvas nodes and thumbnails), and both before a
|
||||
* prefetch (the screen Compare would step to next), which only takes a slot while PREFETCH_RESERVE others stay free.
|
||||
*/
|
||||
export type ScreenshotPriority = "eager" | "lazy" | "prefetch";
|
||||
const PRIORITY_RANK: Record<ScreenshotPriority, number> = { eager: 0, lazy: 1, prefetch: 2 };
|
||||
type ImageLoad = {
|
||||
sha256: string;
|
||||
users: number;
|
||||
@@ -279,6 +283,12 @@ type ImageLoad = {
|
||||
};
|
||||
|
||||
const DECODE_SLOTS = 4;
|
||||
/**
|
||||
* The slots a prefetch leaves free: a running read keeps its slot after it is let go, so these are what the two
|
||||
* screenshots of the screen the reviewer does step to start in, whichever way that is. A prefetch waiting for a slot
|
||||
* is dropped, unread, when it is let go first.
|
||||
*/
|
||||
const PREFETCH_RESERVE = 2;
|
||||
/**
|
||||
* Released screenshots keep their Blob URL, up to this many and this many bytes in all, so panning
|
||||
* back needs no new decode.
|
||||
@@ -299,7 +309,7 @@ export class ArtifactReportArchive {
|
||||
/** Decoded screenshots nobody uses, least recently released first, and their total size. */
|
||||
private readonly retained = new Map<string, { url: string; bytes: number }>();
|
||||
private retainedBytes = 0;
|
||||
private readonly queues: Record<ScreenshotPriority, ImageLoad[]> = { eager: [], lazy: [] };
|
||||
private readonly queues: Record<ScreenshotPriority, ImageLoad[]> = { eager: [], lazy: [], prefetch: [] };
|
||||
private disposed = false;
|
||||
private running = 0;
|
||||
private retainedLimit = RETAINED_SCREENSHOTS;
|
||||
@@ -418,7 +428,8 @@ export class ArtifactReportArchive {
|
||||
|
||||
/**
|
||||
* A verified Blob URL for an embedded screenshot. Each call is one use until `release`. At most
|
||||
* four screenshots are read and hashed at once; eager requests wait ahead of lazy ones.
|
||||
* four screenshots are read and hashed at once; eager requests wait ahead of lazy ones, and both
|
||||
* ahead of a prefetch.
|
||||
*/
|
||||
async resolve(reference: string, priority: ScreenshotPriority = "lazy"): Promise<string> {
|
||||
const sha256 = IMAGE_REFERENCE.exec(reference)?.[1];
|
||||
@@ -429,7 +440,7 @@ export class ArtifactReportArchive {
|
||||
const existing = this.loads.get(sha256);
|
||||
if (existing) {
|
||||
existing.users++;
|
||||
if (priority === "eager" && existing.priority === "lazy") this.promote(existing);
|
||||
if (PRIORITY_RANK[priority] < PRIORITY_RANK[existing.priority]) this.promote(existing, priority);
|
||||
return existing.pending;
|
||||
}
|
||||
const kept = this.retained.get(sha256);
|
||||
@@ -460,7 +471,7 @@ export class ArtifactReportArchive {
|
||||
|
||||
dispose(): void {
|
||||
this.disposed = true;
|
||||
for (const load of this.queues.eager.splice(0).concat(this.queues.lazy.splice(0))) {
|
||||
for (const load of this.waitingLoads()) {
|
||||
load.waiting?.drop(new Error("This report was closed."));
|
||||
}
|
||||
for (const load of this.loads.values()) if (load.url) URL.revokeObjectURL(load.url);
|
||||
@@ -476,7 +487,7 @@ export class ArtifactReportArchive {
|
||||
* used them releases them against the report shown next, so the ones still in use are dropped here instead.
|
||||
*/
|
||||
trim(): void {
|
||||
for (const load of this.queues.eager.splice(0).concat(this.queues.lazy.splice(0))) {
|
||||
for (const load of this.waitingLoads()) {
|
||||
load.waiting?.drop(new Error("This screenshot is no longer in use."));
|
||||
}
|
||||
// What the Viewer was showing is kept as released, most recent last, so switching back shows it at once.
|
||||
@@ -523,7 +534,7 @@ export class ArtifactReportArchive {
|
||||
}
|
||||
|
||||
private acquireSlot(load: ImageLoad): Promise<void> {
|
||||
if (this.running < DECODE_SLOTS) {
|
||||
if (this.running < this.slotsFor(load)) {
|
||||
this.running++;
|
||||
return Promise.resolve();
|
||||
}
|
||||
@@ -533,6 +544,11 @@ export class ArtifactReportArchive {
|
||||
});
|
||||
}
|
||||
|
||||
/** How many slots may be running when `load` starts: all of them, or for a prefetch all but the reserve. */
|
||||
private slotsFor(load: ImageLoad): number {
|
||||
return load.priority === "prefetch" ? DECODE_SLOTS - PREFETCH_RESERVE : DECODE_SLOTS;
|
||||
}
|
||||
|
||||
/** Hand a finished decode's slot to the next waiting load that someone still uses. */
|
||||
private releaseSlot(): void {
|
||||
for (let load = this.nextWaiting(); load; load = this.nextWaiting()) {
|
||||
@@ -549,16 +565,38 @@ export class ArtifactReportArchive {
|
||||
this.running--;
|
||||
}
|
||||
|
||||
/**
|
||||
* The next waiting load the slot being handed on may start. A prefetch waits while the other running loads would
|
||||
* leave less than the reserve free, unless it was let go, which drops it.
|
||||
*/
|
||||
private nextWaiting(): ImageLoad | undefined {
|
||||
return this.queues.eager.shift() ?? this.queues.lazy.shift();
|
||||
const load = this.queues.eager[0] ?? this.queues.lazy[0] ?? this.queues.prefetch[0];
|
||||
if (load && load.users > 0 && this.running > this.slotsFor(load)) return undefined;
|
||||
return load ? this.queues[load.priority].shift() : undefined;
|
||||
}
|
||||
|
||||
private promote(load: ImageLoad): void {
|
||||
load.priority = "eager";
|
||||
const index = this.queues.lazy.indexOf(load);
|
||||
private waitingLoads(): ImageLoad[] {
|
||||
return this.queues.eager.splice(0).concat(this.queues.lazy.splice(0), this.queues.prefetch.splice(0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Move a load up to `priority`. A prefetch waiting for its reserve that the reviewer has stepped to starts at once
|
||||
* when a slot is free, rather than waiting for a running read to finish.
|
||||
*/
|
||||
private promote(load: ImageLoad, priority: ScreenshotPriority): void {
|
||||
const queue = this.queues[load.priority];
|
||||
load.priority = priority;
|
||||
const index = queue.indexOf(load);
|
||||
if (index < 0) return;
|
||||
this.queues.lazy.splice(index, 1);
|
||||
this.queues.eager.push(load);
|
||||
queue.splice(index, 1);
|
||||
if (load.waiting && this.running < this.slotsFor(load)) {
|
||||
const waiting = load.waiting;
|
||||
delete load.waiting;
|
||||
this.running++;
|
||||
waiting.start();
|
||||
return;
|
||||
}
|
||||
this.queues[priority].push(load);
|
||||
}
|
||||
|
||||
/** Keep a released URL; beyond either limit the least recently released ones are revoked. */
|
||||
|
||||
@@ -41,9 +41,10 @@ export type KeyPress = {
|
||||
export type KeyHold = {
|
||||
/**
|
||||
* Starts holding `code` after its first step already landed. `step` takes the next step and
|
||||
* says whether there was one; the hold ends by itself when there is not.
|
||||
* says whether there was one; the hold ends by itself when there is not. `onEnd` hears the hold
|
||||
* end, however it ends.
|
||||
*/
|
||||
begin: (code: string, step: () => boolean) => KeyPress;
|
||||
begin: (code: string, step: () => boolean, onEnd?: () => void) => KeyPress;
|
||||
/** Ends the hold as an interruption: another key, blur, a field or dialog taking the keyboard. */
|
||||
end: () => void;
|
||||
/** Ends the hold because `code` went up, if it is the key being held. */
|
||||
@@ -53,8 +54,8 @@ export type KeyHold = {
|
||||
* not end it, so ⇧ or ⌘ can join a held key. Call it first in the listener, before any guard.
|
||||
*/
|
||||
interrupt: (event: KeyboardEvent) => void;
|
||||
/** Whether `code` is the key being held. */
|
||||
holding: (code: string) => boolean;
|
||||
/** Whether `code` is the key being held, or without one, whether any key is. */
|
||||
holding: (code?: string) => boolean;
|
||||
};
|
||||
|
||||
const MODIFIER_KEYS = new Set(["Shift", "Control", "Alt", "Meta"]);
|
||||
@@ -115,18 +116,20 @@ export function glideWhileHeld(press: KeyPress, move: (steps: number) => boolean
|
||||
|
||||
/** One held key at a time, timed on the schedule above. */
|
||||
export function createKeyHold(): KeyHold {
|
||||
let current: { code: string; timer: ReturnType<typeof setTimeout>; press: { held: boolean; released: boolean } } | undefined;
|
||||
let current: { code: string; timer: ReturnType<typeof setTimeout>; press: { held: boolean; released: boolean }; onEnd?: (() => void) | undefined } | undefined;
|
||||
const finish = (released: boolean) => {
|
||||
if (current) {
|
||||
clearTimeout(current.timer);
|
||||
current.press.held = false;
|
||||
current.press.released = released;
|
||||
}
|
||||
const ended = current;
|
||||
current = undefined;
|
||||
if (ended) {
|
||||
clearTimeout(ended.timer);
|
||||
ended.press.held = false;
|
||||
ended.press.released = released;
|
||||
ended.onEnd?.();
|
||||
}
|
||||
};
|
||||
const end = () => finish(false);
|
||||
return {
|
||||
begin(code, step) {
|
||||
begin(code, step, onEnd) {
|
||||
end();
|
||||
let count = 1;
|
||||
const tick = () => {
|
||||
@@ -137,7 +140,7 @@ export function createKeyHold(): KeyHold {
|
||||
count += 1;
|
||||
};
|
||||
const state = { held: true, released: false };
|
||||
current = { code, timer: setTimeout(tick, HOLD_INITIAL_DELAY_MS), press: state };
|
||||
current = { code, timer: setTimeout(tick, HOLD_INITIAL_DELAY_MS), press: state, onEnd };
|
||||
return {
|
||||
get held() { return state.held; },
|
||||
get released() { return state.released; },
|
||||
@@ -151,6 +154,6 @@ export function createKeyHold(): KeyHold {
|
||||
interrupt(event) {
|
||||
if (current && !event.repeat && event.code !== current.code && !MODIFIER_KEYS.has(event.key)) end();
|
||||
},
|
||||
holding: (code) => current?.code === code,
|
||||
holding: (code) => (code === undefined ? current !== undefined : current?.code === code),
|
||||
};
|
||||
}
|
||||
Reference in new issue
Block a user