Compare commits

...
Author SHA1 Message Date
Brent Vatne cfaae410a3 Merge remote-tracking branch 'origin/main' into @brent/large-moves 2026-10-18 16:55:53 -07:00
Brent Vatne 5321352264 Merge remote-tracking branch 'origin/main' into @brent/large-moves
# Conflicts:
#	src/review/evidence-assessment.ts
#	viewer/src/components/panels/visual-diff.tsx
2026-10-18 16:55:50 -07:00
Brent Vatne 6a505a2d44 Merge remote-tracking branch 'origin/main' into @brent/large-moves
# Conflicts:
#	test/node/public-review-validation.test.mjs
2026-10-18 16:29:50 -07:00
Brent Vatne f30e9cc87b Swipe draws a moved area on each side of the divider
Swipe drew outlines once, where content is in After, so a 395-pixel move showed nothing where the card was on
Before's half. With a moved area, each side now draws its own outlines over its own half, Before's back by the
move as in Split and Flip.
2026-10-18 16:25:27 -07:00
Brent Vatne 8cf8ec0f7f Large moves: catch moderate changes, compare where content left to its backdrop, read whole pixels directly
From a second three-model review of this pull request:

- After aligning a large move, only pixels differing by more than 140 in a channel counted, a limit set for
  re-rasterized text. A grey badge, a button in another shade or a low-contrast label inside the moved content
  passed. A 4×4 block of pixels differing by more than 40 is now a change too; antialiased edges and hairlines
  against another backdrop are thinner. On euxy#163 this drops two false moves the old limit let through (a
  Settings pill matched to a neighbour without its "Off" label, and Off matched to Record 178 pixels up) and finds
  the real one, "1 bar" moving 204 pixels left. The Share card (395 pixels) and the Patterns rows (204) still
  read as moves.
- Where the content left counted as plain backdrop when its luminance hardly spread: a flat panel of another
  colour, or a small badge in a large vacated area, passed and lost its outline. It must now match the colour
  around it (the median of the pixels just outside), with no solid block drawn on it.
- Whole-pixel shifts read Before's pixels directly instead of interpolating, with the same result, and the large
  move measures the arrived region's own difference once. The drift search on euxy#163's and #164's 141 changed
  screens takes 40 s of CPU instead of 232 s; eight full-width regions take 0.4 s instead of 3.6 s.
2026-10-18 16:25:27 -07:00
Brent Vatne 53af3d4b8d Large moves: check where the content left, keep small changes, and draw them in the Viewer
From a three-model review of this pull request (Codex, Grok and Claude each found the first three):

- The Viewer dropped a move whose amount passed 100: it bounded the amount in pixels like the offsets in percent,
  so the 395-pixel card drew as one plain change at its new place on both sides. The amount is now bounded by the
  review's own limit (8192), the offsets by 100 as before.
- Only the region the content arrived in was checked. The content that left must now be intact where the move
  takes it (a deletion is not a move), and the place it left must be plain backdrop in After for that region to be
  part of the move; anything drawn there stays a change of its own.
- A block of strongly different pixels inside a moved region was allowed up to 0.1% of its area (a 29×29 icon on
  euxy's card). A 2×2 block of them is now a change, however small; only scattered antialiased pixels pass.
- A drift across the move ties toward 0, not -3: content the same all down a horizontal move kept a -3 offset.
- Members of a move list the region it arrived in first, and the published region takes its location from it.
- Publishing is its own function (publishMeasuredRegions), and a merged share is capped at 100: rounded member
  shares could pass it, and the Viewer drops a region over 100.
- Regions are clipped to the screenshot before measuring (fractional or overhanging edges found nothing), and each
  pair is tried once.
2026-10-18 10:45:57 -07:00
Brent Vatne 6e134b8f05 Large moves read as one moved region instead of fragments
A card recentred on iPhone Duo's inner display moved 395 pixels. The drift search only looks 4 pixels across and
20 down, so the comparison's regions for it (where the card left, where it arrived, and fragments of the overlap)
all published as changes: orange boxes drawn in the same place on both sides, half of them over empty sheet.

regionMoves looks among the regions the drift search left unexplained for a pair that is one element's two ends:
side by side along an axis, alike across it, one brighter and one darker. The pair only names the axis and how far
to look; the distance is where After's brightness profile across the arrived region best matches Before's, a fit
that has to be unambiguous (repeating content lines up at several distances and is left alone), and the pixels
must agree once aligned. A move that checks out takes in the other unexplained regions it explains, fragments of
the same element, and publishes as one region: where the content is now, with the shift, which the Viewer already
draws as a dashed move outline on both sides.

On euxy's Share sheet (brentvatne/euxy#163, inner display) that is one region, x 890 to 1964, the card exactly,
shifted 395 right, in 0.7 s; the keys, which changed width, and the screen behind the sheet stay changes.

A published shift was capped at 64 pixels as "layout drift"; a move within a screenshot is now valid.
2026-10-18 10:24:16 -07:00
11 changed files with 607 additions and 16 deletions

No files matched your search

+1 -1
View File
@@ -50,7 +50,7 @@
"test:node": "node --test test/node/*.test.mjs",
"test:hosting": "npm --prefix viewer-host run typecheck && npm --prefix viewer-host test",
"test:viewer:artifacts": "node --test test/browser/artifact-report.browser.mjs test/browser/artifact-cache.browser.mjs",
"test:viewer:browser": "node --test test/browser/screenshot-image.browser.mjs test/browser/inspector-notes.browser.mjs test/browser/inspector-variants.browser.mjs test/browser/inspector-source-navigation.browser.mjs test/browser/map-edge-presentation.browser.mjs test/browser/local-ci-view.browser.mjs test/browser/report-viewer.browser.mjs",
"test:viewer:browser": "node --test test/browser/screenshot-image.browser.mjs test/browser/swipe-outlines.browser.mjs test/browser/inspector-notes.browser.mjs test/browser/inspector-variants.browser.mjs test/browser/inspector-source-navigation.browser.mjs test/browser/map-edge-presentation.browser.mjs test/browser/local-ci-view.browser.mjs test/browser/report-viewer.browser.mjs",
"test:viewer:e2e": "npm run test:viewer:browser && playwright test",
"typecheck": "tsc -p tsconfig.json --noEmit && tsc -p viewer/tsconfig.json --noEmit",
"lint": "eslint .",
+8 -2
View File
@@ -75,11 +75,17 @@ function assertReviewFields(surface: Surface, enforceComparisonEvidence: boolean
}
}
/** A region's move between the screenshots: finite, and small enough to be layout drift rather than another screen. */
/**
* The farthest a region may move between the screenshots, in screenshot pixels: within the largest screenshot a
* device takes (an element recentred on a wide display moves hundreds of pixels), not an unbounded number.
*/
const MAX_SHIFT = 8192;
/** A region's move between the screenshots: finite, and within a screenshot. */
function validShift(shift: unknown): boolean {
if (!shift || typeof shift !== "object") return false;
const { x, y } = shift as { x?: unknown; y?: unknown };
return typeof x === "number" && typeof y === "number" && Number.isFinite(x) && Number.isFinite(y) && Math.abs(x) <= 64 && Math.abs(y) <= 64;
return typeof x === "number" && typeof y === "number" && Number.isFinite(x) && Number.isFinite(y) && Math.abs(x) <= MAX_SHIFT && Math.abs(y) <= MAX_SHIFT;
}
function assertVisualVerdict(visual: PublicVisualVerdict, enforceComparisonEvidence: boolean, paired: boolean): void {
+50 -5
View File
@@ -27,7 +27,7 @@ import {
} from "./visual-evidence.js";
import { AGENT_DEVICE_VERSION } from "../shared/agent-device-version.js";
import { STATUS_BAR_BAND_PERCENT, decodePng, differentPixelsInRect, maxColorDistance, type DecodedFrame } from "../shared/png-evidence.js";
import { measureRegionShifts } from "./region-shift.js";
import { measureRegionMoves, type RegionMove, type RegionShift } from "./region-shift.js";
export const DEFAULT_VISUAL_THRESHOLD = 0.1;
export const DEFAULT_EVIDENCE_TIME_BUDGET_MS = 10 * 60_000;
@@ -142,16 +142,61 @@ function visualVerdict(assessment: VisualEvidenceAssessment, threshold: number):
};
}
type PublishedRegion = NonNullable<PublicVisualVerdict["regions"]>[number];
/** A region as published: the fields a review carries, without the comparison's own bookkeeping. */
function publishedRegion(region: VisualDiffRegion): PublishedRegion {
return { rect: region.rect, normalizedRect: region.normalizedRect, differentPixels: region.differentPixels,
shareOfDiffPercentage: region.shareOfDiffPercentage, dominantChange: region.dominantChange, location: region.location };
}
/**
* The regions to publish from every region the comparison found, given what moved: each region with its small
* shift, if one explains it, and each large move as one region in place of the regions it explains (where the
* content is now, their pixels and share, its location the region the content arrived in), largest share first.
* `allRegionsMoved` when every region, before any are left out, moved.
*/
export function publishMeasuredRegions(all: readonly VisualDiffRegion[], shifts: ReadonlyArray<RegionShift | undefined>,
moves: readonly RegionMove[], width: number, height: number): Pick<PublicVisualVerdict, "regions" | "allRegionsMoved"> {
const merged = new Set(moves.flatMap(move => move.members));
const percent = (value: number, total: number) => Math.round((value / total) * 10_000) / 100;
const regions: PublishedRegion[] = [
...all.flatMap((region, index) => {
if (merged.has(index)) return [];
const shift = shifts[index];
return [{ ...publishedRegion(region), ...(shift ? { shift } : {}) }];
}),
...moves.map(move => {
const members = move.members.map(index => all[index]!);
return {
rect: move.rect,
normalizedRect: { x: percent(move.rect.x, width), y: percent(move.rect.y, height), width: percent(move.rect.width, width), height: percent(move.rect.height, height) },
differentPixels: members.reduce((sum, region) => sum + region.differentPixels, 0),
// Each member's share is rounded, so their sum can pass 100; a share is at most the whole difference.
shareOfDiffPercentage: Math.min(100, Math.round(members.reduce((sum, region) => sum + region.shareOfDiffPercentage, 0) * 100) / 100),
dominantChange: "mixed", location: members[0]!.location, shift: move.shift,
};
}),
];
return {
regions: regions.sort((left, right) => right.shareOfDiffPercentage - left.shareOfDiffPercentage).slice(0, MAX_REGIONS),
...(regions.length > 0 && regions.every(region => region.shift) ? { allRegionsMoved: true as const } : {}),
};
}
/**
* The published regions with how far their content moved, where a move explains it: a layout that shifted by a
* device pixel reads as moved, not as changed. Every region the comparison found is measured, not only the ones
* published, so `allRegionsMoved` can say nothing else on the screen changed. A measurement that fails leaves the
* regions as they were.
* device pixel reads as moved, not as changed, and an element that moved further (a card recentred on a wider
* screen) reads as one moved region instead of the fragments the comparison split it into. Every region the
* comparison found is measured, not only the ones published, so `allRegionsMoved` can say nothing else on the
* screen changed. A measurement that fails leaves the regions as they were.
*/
async function withRegionShifts(basePath: string, headPath: string, all: readonly VisualDiffRegion[], published: NonNullable<PublicVisualVerdict["regions"]>):
Promise<Pick<PublicVisualVerdict, "regions" | "allRegionsMoved">> {
try {
const shifts = await measureRegionShifts(basePath, headPath, all.map(region => region.rect));
const { shifts, moves, width, height } = await measureRegionMoves(basePath, headPath,
all.map(region => ({ ...region.rect, dominantChange: region.dominantChange })));
if (moves.length) return publishMeasuredRegions(all, shifts, moves, width, height);
const shiftOf = new Map(all.map((region, index) => [region.rect, shifts[index]] as const));
return {
regions: published.map(region => {
+266 -3
View File
@@ -63,12 +63,15 @@ function at(source: Image, x: number, y: number, channel?: number): number {
return value(x0, y0) * (1 - fx) * (1 - fy) + value(x1, y0) * fx * (1 - fy) + value(x0, y1) * (1 - fx) * fy + value(x1, y1) * fx * fy;
}
/** How badly After's region matches Before shifted by (sx, sy). */
/** How badly After's region matches Before shifted by (sx, sy). A whole-pixel shift reads Before's pixels directly. */
function mismatch(base: Image, head: Image, rect: Rect, sx: number, sy: number): number {
const whole = Number.isInteger(sx) && Number.isInteger(sy);
let error = 0;
for (let y = rect.y; y < rect.y + rect.height; y += 1) {
const by = Math.min(base.height - 1, Math.max(0, y - sy));
for (let x = rect.x; x < rect.x + rect.width; x += 1) {
error += Math.abs(at(base, x - sx, y - sy) - head.luminance[y * head.width + x]!);
const before = whole ? base.luminance[by * base.width + Math.min(base.width - 1, Math.max(0, x - sx))]! : at(base, x - sx, y - sy);
error += Math.abs(before - head.luminance[y * head.width + x]!);
}
}
return error;
@@ -141,10 +144,270 @@ export function regionShifts(baseFrame: DecodedFrame, headFrame: DecodedFrame, r
return regions.map(region => regionShift(base, head, region));
}
/**
* A move too large for the drift search: content that left one area and arrived in another, such as a card that
* went from the left of a wide sheet to its centre. `rect` is where the moved content is in After, `shift` how far it
* went, and `members` the regions it explains (indices into the regions measured), the region it arrived in first.
*/
export type RegionMove = { rect: Rect; shift: RegionShift; members: number[] };
type Axis = "x" | "y";
/** How alike two regions' extents across the move must be to be one element's two ends: overlap and size. */
const PAIR_OVERLAP = 0.8;
const PAIR_SIZE = 0.25;
/** Rows (or columns) sampled for the brightness profiles that estimate a large move: every second one is plenty. */
const PROFILE_STEP = 2;
/** Another local best this close to the best makes a large move ambiguous: repeating content (a grid, a list). */
const AMBIGUOUS_LARGE = 1.05;
/** The share of the arrived region the move must explain, as for a small move. */
const MIN_EXPLAINED_LARGE = MIN_EXPLAINED;
/** After aligning by the move, at most this share of a region may still differ strongly (antialiased edges). */
const CHANGED_SHARE = 0.001;
/** How far across the move a large one may also drift, as layout below a moved element does; ties keep it in line. */
const ACROSS_OFFSETS = [0, -1, 1, -2, 2, -3, 3];
/**
* Blocks that give something drawn away, where every pixel differs by more than `channel` in some channel: a 2×2
* block of strongly different pixels (an icon, a badge, a mark), or a 4×4 block of moderately different ones (a
* tint, a low-contrast label, a grey badge). Antialiased edges and hairlines against another backdrop are thinner:
* the chevrons in euxy's Patterns rows (brentvatne/euxy#163) cross a curve that differs by up to 69 in 3×3 blocks
* but only 26 in 4×4 ones, while a grey "Off" label the move did not bring differs by 55 in 4×4 blocks.
*/
const SOLID_BLOCKS = [{ size: 2, channel: CHANGED_CHANNEL }, { size: 4, channel: 40 }];
const extent = (rect: Rect, axis: Axis) => axis === "x" ? { start: rect.x, size: rect.width } : { start: rect.y, size: rect.height };
const across = (axis: Axis): Axis => axis === "x" ? "y" : "x";
const shiftAlong = (axis: Axis, along: number, other = 0): RegionShift => axis === "x" ? { x: along, y: other } : { x: other, y: along };
/** Whether two regions could be one element's two ends of a move along `axis`: side by side, alike across it. */
function pairAlong(a: Rect, b: Rect, axis: Axis): boolean {
const ea = extent(a, axis), eb = extent(b, axis), ca = extent(a, across(axis)), cb = extent(b, across(axis));
const separate = ea.start + ea.size <= eb.start || eb.start + eb.size <= ea.start;
const overlap = Math.min(ca.start + ca.size, cb.start + cb.size) - Math.max(ca.start, cb.start);
const alike = Math.abs(ea.size - eb.size) <= PAIR_SIZE * Math.max(ea.size, eb.size);
return separate && alike && overlap >= PAIR_OVERLAP * Math.min(ca.size, cb.size);
}
/** Mean luminance along `axis` of a band across it: one value per column (axis x) or row (axis y). */
function profile(source: Image, axis: Axis, bandStart: number, bandEnd: number): Float32Array {
const length = axis === "x" ? source.width : source.height;
const values = new Float32Array(length);
for (let position = 0; position < length; position += 1) {
let sum = 0, count = 0;
for (let other = bandStart; other < bandEnd; other += PROFILE_STEP) {
sum += axis === "x" ? source.luminance[other * source.width + position]! : source.luminance[position * source.width + other]!;
count += 1;
}
values[position] = count ? sum / count : 0;
}
return values;
}
/**
* Whether a region holds something drawn: a solid block (SOLID_BLOCKS), or more than `allowed` strongly different
* pixels anywhere. `difference` is how much the pixel at (x, y) differs, in its most different channel.
*/
function drawnIn(rect: Rect, difference: (x: number, y: number) => number, allowed = Infinity): boolean {
// Per block: how many pixels differ in a row up to here, and for each column, how many rows have such a run.
const blocks = SOLID_BLOCKS.map(block => ({ ...block, run: 0, rows: new Uint32Array(rect.width) }));
let strong = 0;
for (let y = rect.y; y < rect.y + rect.height; y += 1) {
for (const block of blocks) block.run = 0;
for (let x = rect.x; x < rect.x + rect.width; x += 1) {
const value = difference(x, y), column = x - rect.x;
if (value > CHANGED_CHANNEL && ++strong > allowed) return true;
for (const block of blocks) {
block.run = value > block.channel ? block.run + 1 : 0;
block.rows[column] = block.run >= block.size ? block.rows[column]! + 1 : 0;
if (block.rows[column]! >= block.size) return true;
}
}
}
return false;
}
/**
* Whether, aligned by an integer move, some of the region still differs: content that changed, not only moved. A
* whole-pixel move copies the pixels, so only a sliver may differ strongly (antialiased edges against another
* backdrop, never more than CHANGED_SHARE of the region), and never a solid block. Pixels the move brings in from
* off screen differ.
*/
function changedAfterLargeMove(base: Image, head: Image, rect: Rect, sx: number, sy: number): boolean {
return drawnIn(rect, (x, y) => {
const bx = x - sx, by = y - sy;
if (bx < 0 || by < 0 || bx >= base.width || by >= base.height) return 255;
const h = (y * head.width + x) * 4, b = (by * base.width + bx) * 4;
return Math.max(Math.abs(base.frame.data[b]! - head.frame.data[h]!), Math.abs(base.frame.data[b + 1]! - head.frame.data[h + 1]!),
Math.abs(base.frame.data[b + 2]! - head.frame.data[h + 2]!));
}, Math.max(CHANGED_PIXELS, rect.width * rect.height * CHANGED_SHARE));
}
/** How much of a region's difference an integer move explains: 1 is all of it, 0 none. `unshifted` is the region's own. */
function explained(base: Image, head: Image, rect: Rect, shift: RegionShift, unshifted = mismatch(base, head, rect, 0, 0)): number {
return unshifted === 0 ? 0 : 1 - mismatch(base, head, rect, shift.x, shift.y) / unshifted;
}
/** Whether a region's content, moved by `shift`, is the same in After: explained, and nothing changed in it. */
function movedIntact(base: Image, head: Image, rect: Rect, shift: RegionShift): boolean {
return rect.width > 0 && rect.height > 0 && explained(base, head, rect, shift) >= MIN_EXPLAINED_LARGE
&& !changedAfterLargeMove(base, head, rect, shift.x, shift.y);
}
/**
* Whether a part of After where content left is plain backdrop: the colour around it (the median of the pixels just
* outside it, not in the moved content's `outline`), with nothing drawn on it. A part with nothing around it is not.
*/
function plain(head: Image, rect: Rect, outline: Rect): boolean {
if (rect.width <= 0 || rect.height <= 0) return true;
const around: number[][] = [[], [], []];
const add = (x: number, y: number) => {
if (x < 0 || y < 0 || x >= head.width || y >= head.height) return;
if (x >= outline.x && y >= outline.y && x < outline.x + outline.width && y < outline.y + outline.height) return;
for (let channel = 0; channel < 3; channel += 1) around[channel]!.push(head.frame.data[(y * head.width + x) * 4 + channel]!);
};
for (let x = rect.x - 1; x <= rect.x + rect.width; x += 1) { add(x, rect.y - 1); add(x, rect.y + rect.height); }
for (let y = rect.y; y < rect.y + rect.height; y += 1) { add(rect.x - 1, y); add(rect.x + rect.width, y); }
if (!around[0]!.length) return false;
const backdrop = around.map(values => values.sort((a, b) => a - b)[values.length >> 1]!);
return !drawnIn(rect, (x, y) => {
const offset = (y * head.width + x) * 4;
return Math.max(Math.abs(head.frame.data[offset]! - backdrop[0]!), Math.abs(head.frame.data[offset + 1]! - backdrop[1]!),
Math.abs(head.frame.data[offset + 2]! - backdrop[2]!));
});
}
/** The parts of `rect` before and after `outline` along `axis`: what is left of it outside the outline. */
function outside(rect: Rect, outline: Rect, axis: Axis): Rect[] {
const r = extent(rect, axis), o = extent(outline, axis);
const parts: Array<[number, number]> = [[r.start, Math.min(r.start + r.size, o.start)], [Math.max(r.start, o.start + o.size), r.start + r.size]];
return parts.filter(([from, to]) => to > from)
.map(([from, to]) => (axis === "x" ? { ...rect, x: from, width: to - from } : { ...rect, y: from, height: to - from }));
}
function clip(rect: Rect, width: number, height: number): Rect {
const x = Math.max(0, Math.floor(rect.x)), y = Math.max(0, Math.floor(rect.y));
return { x, y, width: Math.max(0, Math.min(width, Math.ceil(rect.x + rect.width)) - x), height: Math.max(0, Math.min(height, Math.ceil(rect.y + rect.height)) - y) };
}
function union(a: Rect, b: Rect): Rect {
const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
}
/**
* The large move a pair of regions shows, if one does: `left` is where content was (it differs because the content
* left), `arrived` where it is now, both already clipped to the screenshot. The pair only names the axis and how far
* to look; the distance is where After's brightness profile across the arrived region best matches Before's, and
* the pixels must agree once aligned, both where the content arrived and where the content that left went.
*/
function pairMove(base: Image, head: Image, left: Rect, arrived: Rect, axis: Axis): RegionShift | undefined {
const a = extent(arrived, axis), l = extent(left, axis), band = extent(arrived, across(axis)), lb = extent(left, across(axis));
const bandStart = Math.max(band.start, lb.start), bandEnd = Math.min(band.start + band.size, lb.start + lb.size);
if (bandEnd <= bandStart || a.size <= 0) return undefined;
const baseProfile = profile(base, axis, bandStart, bandEnd), headProfile = profile(head, axis, bandStart, bandEnd);
const length = baseProfile.length;
// Content moving toward the arrived region: the distance is positive when it lies after the region it left.
const sign = a.start > l.start ? 1 : -1;
const farthest = Math.abs(a.start + a.size - l.start) + Math.abs(l.start + l.size - a.start);
const errors: Array<{ distance: number; error: number }> = [];
for (let distance = (axis === "x" ? MAX_SHIFT_X : MAX_SHIFT_Y) + 1; distance <= farthest; distance += 1) {
const move = sign * distance;
let sum = 0, count = 0;
for (let position = a.start; position < a.start + a.size; position += 1) {
const from = position - move;
if (from < 0 || from >= length) continue;
sum += Math.abs(headProfile[position]! - baseProfile[from]!);
count += 1;
}
if (count >= a.size / 2) errors.push({ distance: move, error: sum / count });
}
if (errors.length < 3) return undefined;
const minima = errors.filter((fit, index) => index > 0 && index < errors.length - 1
&& fit.error <= errors[index - 1]!.error && fit.error <= errors[index + 1]!.error);
if (!minima.length) return undefined;
const best = minima.reduce((least, fit) => (fit.error < least.error ? fit : least));
if (minima.some(fit => fit !== best && Math.abs(fit.distance - best.distance) > 2 && fit.error <= best.error * AMBIGUOUS_LARGE + 1e-6)) return undefined;
// The pixels decide: across the move it may also drift a little, as content below a moved element does. A tie
// keeps the move in line (content the same all across it fits every drift equally).
let chosen: RegionShift | undefined, fit = -Infinity;
const unshifted = mismatch(base, head, arrived, 0, 0);
for (const other of ACROSS_OFFSETS) {
const shift = shiftAlong(axis, best.distance, other);
const share = explained(base, head, arrived, shift, unshifted);
if (share > fit) { fit = share; chosen = shift; }
}
if (!chosen || fit < MIN_EXPLAINED_LARGE || changedAfterLargeMove(base, head, arrived, chosen.x, chosen.y)) return undefined;
// The content that left must be intact where the move takes it: a deletion is not a move.
const landed = clip({ ...left, x: left.x + chosen.x, y: left.y + chosen.y }, head.width, head.height);
return movedIntact(base, head, landed, chosen) ? chosen : undefined;
}
/**
* Moves too large for the drift search, among the regions it left unexplained: two regions alike across an axis
* and side by side along it, one darker and one brighter, are the two ends of something that moved. Where the
* content left must be plain backdrop in After for that region to be part of the move; anything drawn there is a
* change of its own and stays one. A move that checks out also takes in any other unexplained region it explains
* (fragments of the same element where its old and new places overlap), and its outline is the moved content in After.
*/
export function regionMoves(baseFrame: DecodedFrame, headFrame: DecodedFrame,
regions: ReadonlyArray<Rect & { dominantChange?: string }>, shifts: ReadonlyArray<RegionShift | undefined>): RegionMove[] {
if (baseFrame.width !== headFrame.width || baseFrame.height !== headFrame.height) return [];
const base = image(baseFrame), head = image(headFrame);
const clipped = regions.map(region => clip(region, head.width, head.height));
const open = new Set(regions.map((_, index) => index).filter(index => !shifts[index] && clipped[index]!.width > 0 && clipped[index]!.height > 0));
const moves: RegionMove[] = [];
// Largest first: the element that moved the most content is the one a reader is looking at.
const order = [...open].sort((left, right) => clipped[right]!.width * clipped[right]!.height - clipped[left]!.width * clipped[left]!.height);
for (let first = 0; first < order.length; first += 1) {
for (let second = first + 1; second < order.length; second += 1) {
const i = order[first]!, j = order[second]!;
if (!open.has(i) || !open.has(j)) continue;
const opposite = new Set([regions[i]!.dominantChange, regions[j]!.dominantChange]);
if (!(opposite.has("brighter") && opposite.has("darker"))) continue;
const a = clipped[i]!, b = clipped[j]!;
for (const axis of ["x", "y"] as const) {
if (!pairAlong(a, b, axis)) continue;
// Either could be where the content arrived; the pixels decide which.
const forward = pairMove(base, head, a, b, axis);
const shift = forward ?? pairMove(base, head, b, a, axis);
if (!shift) continue;
const [leftIndex, arrivedIndex] = forward ? [i, j] : [j, i];
const left = clipped[leftIndex]!, arrived = clipped[arrivedIndex]!;
let rect = clip(union(arrived, { ...left, x: left.x + shift.x, y: left.y + shift.y }), head.width, head.height);
open.delete(i); open.delete(j);
// Where the content left: plain backdrop belongs to the move, anything drawn there is a change of its own.
const members = outside(left, rect, axis).every(part => plain(head, part, rect)) ? [arrivedIndex, leftIndex] : [arrivedIndex];
// Fragments of the same element inside its new place, where the old and new overlap.
for (const k of [...open]) {
const fragment = clipped[k]!;
const inside = fragment.x >= rect.x && fragment.y >= rect.y && fragment.x + fragment.width <= rect.x + rect.width && fragment.y + fragment.height <= rect.y + rect.height;
if (!inside || !movedIntact(base, head, fragment, shift)) continue;
members.push(k); open.delete(k); rect = union(rect, fragment);
}
moves.push({ rect, shift, members });
break;
}
}
}
return moves;
}
/** Reads both PNG screenshots and measures each region's shift. */
export async function measureRegionShifts(basePath: string, headPath: string, regions: readonly Rect[]): Promise<Array<RegionShift | undefined>> {
const [base, head] = await readFrames(basePath, headPath);
return regionShifts(base, head, regions);
}
/** Reads both PNG screenshots once and measures each region's shift, then the large moves the rest show. */
export async function measureRegionMoves(basePath: string, headPath: string, regions: ReadonlyArray<Rect & { dominantChange?: string }>):
Promise<{ shifts: Array<RegionShift | undefined>; moves: RegionMove[]; width: number; height: number }> {
const [base, head] = await readFrames(basePath, headPath);
const shifts = regionShifts(base, head, regions);
return { shifts, moves: regionMoves(base, head, regions, shifts), width: head.width, height: head.height };
}
async function readFrames(basePath: string, headPath: string): Promise<[DecodedFrame, DecodedFrame]> {
const { PNG } = createRequire(import.meta.url.replace(/\?.*$/, ""))("pngjs") as
{ PNG: { sync: { read(bytes: Buffer, options: { checkCRC: boolean }): DecodedFrame } } };
const [base, head] = await Promise.all([readFile(basePath), readFile(headPath)]);
return regionShifts(PNG.sync.read(base, { checkCRC: false }), PNG.sync.read(head, { checkCRC: false }), regions);
return [PNG.sync.read(base, { checkCRC: false }), PNG.sync.read(head, { checkCRC: false })];
}
+64
View File
@@ -0,0 +1,64 @@
import assert from "node:assert/strict";
import test from "node:test";
import { fileURLToPath } from "node:url";
import { chromium, expect } from "@playwright/test";
import { PNG } from "pngjs";
import { createBrowserVite } from "../helpers/browser-vite.mjs";
function png(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")}`;
}
// A card that moved 40% of the width right: it is at 60% in After, so it was at 20% in Before.
const entry = `
import { createRoot } from "react-dom/client";
import { SwipeCompare } from "/src/components/panels/visual-diff.tsx";
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} />
</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 => {
const vite = await createBrowserVite(t, {
configFile: false, root: fileURLToPath(new URL("../../viewer", import.meta.url)),
logLevel: "error", esbuild: { jsx: "automatic" },
plugins: [{
name: "swipe-outlines-fixture",
resolveId: id => id === "/__swipe-outlines.tsx" ? id : undefined,
load: id => id === "/__swipe-outlines.tsx" ? entry : undefined,
configureServer(server) {
server.middlewares.use((request, response, next) => {
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>');
});
},
}],
server: { host: "127.0.0.1", port: 0 },
});
await vite.listen();
const browser = await chromium.launch({ headless: true });
t.after(() => browser.close());
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]) });
await page.goto(`http://127.0.0.1:${vite.httpServer.address().port}/`);
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");
await expect(before).toHaveCount(1);
await expect(after).toHaveCount(1);
const [box, beforeBox, afterBox] = await Promise.all([frame.boundingBox(), before.boundingBox(), after.boundingBox()]);
assert.ok(Math.abs((afterBox.x - beforeBox.x) - 0.4 * box.width) < 1, "Before's outline is back by the move");
// 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, []);
});
+25 -1
View File
@@ -258,7 +258,9 @@ test('a visual region may carry the shift its content moved by, and a malformed
const { assertPublicReview } = await import('../../dist/contracts/review-validation.js');
const valid = JSON.parse(JSON.stringify(reviewWithRegion({ x: 0, y: -4.17 })));
assert.doesNotThrow(() => assertPublicReview(valid));
for (const shift of [{ x: 0 }, { x: 0, y: Number.NaN }, { x: 0, y: 500 }, 'up']) {
// A card recentred on iPhone Duo's inner display moved 395 pixels: a large move is still a move.
assert.doesNotThrow(() => assertPublicReview(JSON.parse(JSON.stringify(reviewWithRegion({ x: 395, y: 0 })))));
for (const shift of [{ x: 0 }, { x: 0, y: Number.NaN }, { x: 0, y: 9000 }, 'up']) {
assert.throws(() => assertPublicReview(reviewWithRegion(shift)), /visual verdict is inconsistent/, JSON.stringify(shift));
}
});
@@ -287,6 +289,28 @@ test('allRegionsMoved is only true, and only where every published region carrie
}
});
test('a large move publishes as one region where the content is now, with its members\' pixels and the arrived region\'s location', async () => {
const { publishMeasuredRegions } = await import('../../dist/review/evidence-assessment.js');
const region = (x, share, location, dominantChange) => ({ index: 0, rect: { x, y: 100, width: 100, height: 200 },
normalizedRect: { x: x / 10, y: 10, width: 10, height: 20 }, differentPixels: share * 100, shareOfDiffPercentage: share,
densityPercentage: 50, shape: 'block', size: 'large', location, dominantChange });
// Arrived first: the card is centred now, so the region says center whichever member has more pixels.
const all = [region(100, 50.01, 'middle-left', 'brighter'), region(450, 50.01, 'center', 'darker')];
const moves = [{ rect: { x: 450, y: 100, width: 100, height: 200 }, shift: { x: 350, y: 0 }, members: [1, 0] }];
const published = publishMeasuredRegions(all, [undefined, undefined], moves, 1000, 1000);
assert.deepEqual(published.regions, [{ rect: { x: 450, y: 100, width: 100, height: 200 }, normalizedRect: { x: 45, y: 10, width: 10, height: 20 },
differentPixels: 10002, shareOfDiffPercentage: 100, dominantChange: 'mixed', location: 'center', shift: { x: 350, y: 0 } }],
'two shares of 50.01 cap at 100, the Viewer\'s bound');
assert.equal(published.allRegionsMoved, true, 'nothing else on the screen changed');
// A change that is not part of the move keeps the screen from reading as only moved, and more regions than the
// published limit keep the largest.
const crowded = [...all, ...Array.from({ length: 9 }, (_, index) => region(index, 0.5, 'top-left', 'mixed'))];
const withChanges = publishMeasuredRegions(crowded, crowded.map(() => undefined), moves, 1000, 1000);
assert.equal(withChanges.allRegionsMoved, undefined);
assert.equal(withChanges.regions.length, 8);
assert.deepEqual(withChanges.regions[0].shift, { x: 350, y: 0 });
});
test("an excluded surface carries no capture evidence", () => {
const excluded = review();
excluded.surfaces[1].excluded = true;
+165 -1
View File
@@ -1,7 +1,7 @@
import assert from "node:assert/strict";
import test from "node:test";
import { Buffer } from "node:buffer";
import { regionShifts } from "../../dist/review/region-shift.js";
import { regionMoves, regionShifts } from "../../dist/review/region-shift.js";
/** A 120×160 frame of a light background with dark text-like bars, drawn `offsetY` pixels lower (fractions blend rows). */
function frame(offsetY, { barColor = 40, extraBar = false } = {}) {
@@ -101,3 +101,167 @@ test("a half-pixel move up and down is judged alike", () => {
const up = regionShifts(frame(0), frame(-0.5), [region])[0], down = regionShifts(frame(0), frame(0.5), [region])[0];
assert.deepEqual([up?.y, down?.y], [-0.5, 0.5]);
});
/**
* A light frame with a dark card of irregular blocks at (x, y): the blocks make every offset look different, as a
* real card's text and icons do. `tile` repeats one such block pattern every `tile` pixels across the whole row
* instead, as a grid of identical cells does, starting `x` pixels in.
*/
function cardFrame({ width = 600, height = 300, x = 60, y = 80, cardWidth = 150, cardHeight = 120, seed = 7, tile } = {}) {
const data = Buffer.alloc(width * height * 4, 240);
for (let index = 3; index < data.length; index += 4) data[index] = 255;
const paint = (px, py, value) => data.fill(value, (py * width + px) * 4, (py * width + px) * 4 + 3);
let state = seed;
const random = () => (state = (state * 1103515245 + 12345) % 2147483648) / 2147483648;
const blocks = Array.from({ length: tile ? 6 : 40 }, () => {
const span = tile ?? cardWidth;
return [Math.floor(random() * (span - 12)), Math.floor(random() * (cardHeight - 8)), 4 + Math.floor(random() * 8), 3 + Math.floor(random() * 5), 80 + Math.floor(random() * 160)];
});
for (let py = y; py < y + cardHeight; py += 1) {
for (let px = tile ? 0 : x; px < (tile ? width : x + cardWidth); px += 1) {
const local = tile ? (((px - x) % tile) + tile) % tile : px - x;
const block = blocks.find(([bx, by, bw, bh]) => local >= bx && local < bx + bw && py - y >= by && py - y < by + bh);
paint(px, py, block ? block[4] : 12);
}
}
return { width, height, data };
}
test("a card that moved far along a row is one move, from the regions where it left and where it arrived", () => {
const regions = [
{ x: 60, y: 80, width: 150, height: 120, dominantChange: "brighter" },
{ x: 330, y: 80, width: 150, height: 120, dominantChange: "darker" },
];
const shifts = regionShifts(cardFrame(), cardFrame({ x: 330 }), regions);
assert.deepEqual(shifts, [undefined, undefined], "too far for the drift search");
assert.deepEqual(regionMoves(cardFrame(), cardFrame({ x: 330 }), regions, shifts),
[{ rect: { x: 330, y: 80, width: 150, height: 120 }, shift: { x: 270, y: 0 }, members: [1, 0] }], "the region it arrived in first");
});
test("a move whose old and new places overlap takes in the fragments of it the comparison found in between", () => {
// A 300-wide card moved 120 right: the comparison sees where it only was, where it only is, and a fragment of the
// overlap whose pixels differ because the card's own content moved over itself.
const base = cardFrame({ width: 700, cardWidth: 300 }), head = cardFrame({ width: 700, cardWidth: 300, x: 180 });
const regions = [
{ x: 60, y: 80, width: 120, height: 120, dominantChange: "brighter" },
{ x: 360, y: 80, width: 120, height: 120, dominantChange: "darker" },
{ x: 200, y: 100, width: 120, height: 40, dominantChange: "mixed" },
];
const [move] = regionMoves(base, head, regions, regions.map(() => undefined));
assert.deepEqual(move, { rect: { x: 180, y: 80, width: 300, height: 120 }, shift: { x: 120, y: 0 }, members: [1, 0, 2] });
});
test("a card that moved far down a column is a vertical move", () => {
const regions = [
{ x: 100, y: 20, width: 150, height: 100, dominantChange: "brighter" },
{ x: 100, y: 330, width: 150, height: 100, dominantChange: "darker" },
];
const base = cardFrame({ height: 480, x: 100, y: 20, cardHeight: 100 }), head = cardFrame({ height: 480, x: 100, y: 330, cardHeight: 100 });
assert.deepEqual(regionMoves(base, head, regions, [undefined, undefined]),
[{ rect: { x: 100, y: 330, width: 150, height: 100 }, shift: { x: 0, y: 310 }, members: [1, 0] }]);
});
test("content that left one place while other content arrived elsewhere is not a move", () => {
const regions = [
{ x: 60, y: 80, width: 150, height: 120, dominantChange: "brighter" },
{ x: 330, y: 80, width: 150, height: 120, dominantChange: "darker" },
];
assert.deepEqual(regionMoves(cardFrame(), cardFrame({ x: 330, seed: 99 }), regions, [undefined, undefined]), [], "another card arrived");
// The pair must be opposite: two regions that both got darker are two changes.
assert.deepEqual(regionMoves(cardFrame(), cardFrame({ x: 330 }), regions.map(region => ({ ...region, dominantChange: "darker" })), [undefined, undefined]), []);
// Regions already explained by a small move are not reconsidered.
assert.deepEqual(regionMoves(cardFrame(), cardFrame({ x: 330 }), regions, [{ x: 0, y: 1 }, undefined]), []);
});
test("repeating content that lines up at several distances is not a move: the distance would be a guess", () => {
// A row of identical cells every 40 pixels, all moved 260 right: 220, 260 and 300 fit about as well.
const regions = [
{ x: 60, y: 80, width: 100, height: 120, dominantChange: "brighter" },
{ x: 300, y: 80, width: 100, height: 120, dominantChange: "darker" },
];
assert.deepEqual(regionMoves(cardFrame({ tile: 40 }), cardFrame({ tile: 40, x: 320 }), regions, [undefined, undefined]), []);
});
/** Two frames laid over each other: the darker pixel of each wins, so a dark card in either shows. */
function overlay(first, second) {
const data = Buffer.from(first.data);
for (let index = 0; index < data.length; index += 1) data[index] = Math.min(first.data[index], second.data[index]);
return { ...first, data };
}
/** Paints a block of one colour into a frame, as a badge or icon drawn on top. */
function withBlock(frame, { x, y, width, height, value }) {
const data = Buffer.from(frame.data);
for (let py = y; py < y + height; py += 1) for (let px = x; px < x + width; px += 1) data.fill(value, (py * frame.width + px) * 4, (py * frame.width + px) * 4 + 3);
return { ...frame, data };
}
const farMove = [
{ x: 60, y: 80, width: 150, height: 120, dominantChange: "brighter" },
{ x: 330, y: 80, width: 150, height: 120, dominantChange: "darker" },
];
test("something new where the card was stays a change: the move takes only the place it arrived", () => {
// The card moved right, and another card took its old place.
const head = overlay(cardFrame({ x: 330 }), cardFrame({ x: 60, seed: 99 }));
assert.deepEqual(regionMoves(cardFrame(), head, farMove, [undefined, undefined]),
[{ rect: { x: 330, y: 80, width: 150, height: 120 }, shift: { x: 270, y: 0 }, members: [1] }]);
// A flat panel in another colour than the backdrop around it: nothing spreads, but it is not the backdrop.
const panel = withBlock(cardFrame({ x: 330 }), { x: 60, y: 80, width: 150, height: 120, value: 180 });
assert.deepEqual(regionMoves(cardFrame(), panel, farMove, [undefined, undefined])[0]?.members, [1]);
// An 8×8 badge where a large card was: a small mark in a large plain area is still something drawn.
const large = [
{ x: 60, y: 80, width: 300, height: 400, dominantChange: "brighter" },
{ x: 600, y: 80, width: 300, height: 400, dominantChange: "darker" },
];
const card = x => cardFrame({ width: 960, height: 560, x, cardWidth: 300, cardHeight: 400 });
assert.deepEqual(regionMoves(card(60), card(600), large, [undefined, undefined])[0]?.members, [1, 0], "plain backdrop joins the move");
const badge = withBlock(card(600), { x: 200, y: 250, width: 8, height: 8, value: 0 });
assert.deepEqual(regionMoves(card(60), badge, large, [undefined, undefined])[0]?.members, [1]);
});
test("content that did not arrive intact is not a move: part of it deleted, or something changed inside it", () => {
// Only the card's top half arrived; its body was deleted.
const deleted = withBlock(cardFrame({ x: 330 }), { x: 330, y: 140, width: 150, height: 60, value: 240 });
assert.deepEqual(regionMoves(cardFrame(), deleted, farMove, [undefined, undefined]), []);
// The card moved, and an 8×8 white mark appeared inside it: a badge is a change, however small.
const marked = withBlock(cardFrame({ x: 330 }), { x: 400, y: 130, width: 8, height: 8, value: 255 });
assert.deepEqual(regionMoves(cardFrame(), marked, farMove, [undefined, undefined]), []);
// Changes of moderate contrast on the dark card: a grey badge, and a button in another shade.
for (const block of [{ x: 400, y: 130, width: 8, height: 8, value: 120 }, { x: 340, y: 160, width: 40, height: 20, value: 60 }]) {
assert.deepEqual(regionMoves(cardFrame(), withBlock(cardFrame({ x: 330 }), block), farMove, [undefined, undefined]), [], JSON.stringify(block));
}
});
test("a hairline that differs where the content arrived is not a change: antialiased edges against another backdrop", () => {
// Two pixels wide and of moderate contrast, as the curve under euxy's Patterns chevrons (brentvatne/euxy#163).
const crossed = withBlock(cardFrame({ x: 330 }), { x: 330, y: 150, width: 150, height: 2, value: 90 });
assert.deepEqual(regionMoves(cardFrame(), crossed, farMove, [undefined, undefined])[0]?.shift, { x: 270, y: 0 });
});
test("content that is the same all down a move along a row keeps the move in line", () => {
// Vertical bars of irregular widths: every small vertical drift fits as well as none.
const bars = x => {
const frame = cardFrame({ x });
const data = Buffer.from(frame.data);
const widths = [6, 11, 4, 9, 14, 5, 8, 12, 7, 10, 6, 13, 9, 5, 11, 7, 6, 8];
let px = x, dark = true;
for (const width of widths) {
for (let py = 80; py < 200; py += 1) for (let column = px; column < Math.min(px + width, x + 150); column += 1) data.fill(dark ? 20 : 200, (py * frame.width + column) * 4, (py * frame.width + column) * 4 + 3);
px += width; dark = !dark;
}
return { ...frame, data };
};
const [move] = regionMoves(bars(60), bars(330), farMove, [undefined, undefined]);
assert.deepEqual(move?.shift, { x: 270, y: 0 });
assert.deepEqual(move?.rect, { x: 330, y: 80, width: 150, height: 120 });
});
test("regions with fractional edges, or reaching past the screenshot, are measured on the pixels they cover", () => {
const regions = [
{ x: 60.4, y: 79.6, width: 149.8, height: 120.5, dominantChange: "brighter" },
{ x: 330.2, y: 80, width: 150.3, height: 400, dominantChange: "darker" },
];
const [move] = regionMoves(cardFrame(), cardFrame({ x: 330 }), regions, [undefined, undefined]);
assert.deepEqual(move?.shift, { x: 270, y: 0 });
});
+9
View File
@@ -45,3 +45,12 @@ test("What changed summarizes a screen whose every area moved, per direction, an
assert.equal(layoutShiftSummary([...moved, ...groupVisualRegions([region(90, 3)])]), undefined);
assert.equal(layoutShiftSummary([]), undefined);
});
test("the Viewer keeps a move hundreds of pixels long: a card recentred on a wide screen", async () => {
const { visualDiff } = await tsImport("../../viewer/src/utils/review-model.ts", import.meta.url);
const parsed = visualDiff({ regions: [{ x: 31.2, y: 21.2, width: 37.6, height: 70.3, share: 63, move: { x: 13.8, y: 0, amount: { x: 395, y: 0 }, unit: "pt" } }], allRegionsMoved: true });
assert.deepEqual(parsed?.regions[0]?.move, { x: 13.8, y: 0, amount: { x: 395, y: 0 }, unit: "pt" });
// An offset is a percent of the image and still bounded by it; the amount only by the review's own limit.
assert.equal(visualDiff({ regions: [{ x: 1, y: 1, width: 10, height: 10, share: 50, move: { x: 140, y: 0, amount: { x: 395, y: 0 }, unit: "pt" } }] })?.regions[0]?.move, undefined);
assert.equal(visualDiff({ regions: [{ x: 1, y: 1, width: 10, height: 10, share: 50, move: { x: 1, y: 0, amount: { x: 9000, y: 0 }, unit: "pt" } }] })?.regions[0]?.move, undefined);
});
@@ -97,6 +97,10 @@
pointer-events: none;
}
.visual-swipe-before { clip-path: inset(0 calc(100% - var(--swipe-position)) 0 0); }
/* 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); }
.visual-swipe-outlines.after { clip-path: inset(0 0 0 var(--swipe-position)); }
.visual-swipe .visual-change-outline { background: transparent; border-style: dashed; }
.visual-swipe-divider {
position: absolute;
+7 -1
View File
@@ -181,7 +181,13 @@ export function SwipeCompare(props: {
}} />
<ScreenshotImage className="visual-swipe-before" src={props.before} alt={`${props.title}, before`}
loading="eager" draggable={false} />
{props.showOutlines === false ? null : <ChangeOutlines changes={props.changes} activeIndex={props.activeIndex} />}
{props.showOutlines === false ? null : props.changes.some(change => change.move) ? (
// A moved area sits where its content is on each side: Before's outlines left of the divider, After's right.
<>
<span className="visual-swipe-outlines before"><ChangeOutlines changes={props.changes} activeIndex={props.activeIndex} /></span>
<span className="visual-swipe-outlines after"><ChangeOutlines changes={props.changes} activeIndex={props.activeIndex} /></span>
</>
) : <ChangeOutlines changes={props.changes} activeIndex={props.activeIndex} />}
{props.systemRegions && props.showOutlines !== false ? <SystemRegionBands regions={props.systemRegions} /> : null}
{props.labels === false ? null : (
<>
+8 -2
View File
@@ -288,11 +288,17 @@ function visualDiffRegion(value: unknown): VisualDiffRegion | undefined {
return { x, y, width, height, share, ...(move ? { move } : {}) };
}
/** The farthest a published move may go, in screenshot pixels (the review contract's own limit). */
const MAX_MOVE_AMOUNT = 8192;
function regionMove(value: unknown): RegionMove | undefined {
const candidate = record(value);
const amount = record(candidate?.amount);
const finite = (entry: unknown): entry is number => typeof entry === "number" && Number.isFinite(entry) && Math.abs(entry) <= 100;
if (!candidate || !amount || !finite(candidate.x) || !finite(candidate.y) || !finite(amount.x) || !finite(amount.y)
// x and y place the outline in percent of the image; the amount is how far, in pixels or points, and a card
// recentred on a wide screen moves hundreds.
const within = (limit: number) => (entry: unknown): entry is number => typeof entry === "number" && Number.isFinite(entry) && Math.abs(entry) <= limit;
const offset = within(100), distance = within(MAX_MOVE_AMOUNT);
if (!candidate || !amount || !offset(candidate.x) || !offset(candidate.y) || !distance(amount.x) || !distance(amount.y)
|| (candidate.unit !== "pt" && candidate.unit !== "px")) return undefined;
return { x: candidate.x, y: candidate.y, amount: { x: amount.x, y: amount.y }, unit: candidate.unit };
}