Skip to content

An open source design system that's fully customizable and agent ready

TypeScript

test(interaction-harness): a busy-window control clock and a marker search in a region (#9872)

Christopher Chedeauc239dafbd505
diff --git a/internal/interaction-harness/README.md b/internal/interaction-harness/README.md
index 87b057343d..eccdde353e 100644
--- a/internal/interaction-harness/README.md
+++ b/internal/interaction-harness/README.md
@@ -218,9 +218,11 @@ entry: in WebKit, with the popover above BottomSheet's open modal dialog, the
sheet's dim held for 155 to 225 ms into a block while the control moved, and
inside the dialog it moves in step with the sheet. `waitForAnimation` and
`blockMainThread`'s `during` never count the control's own animation, so on
-a dialog they still wait for the backdrop's. Track it from the
-same screencast (`trackMarker(page, frames, {rgb: CONTROL_RGB})`) and pass it
-as `control`: the component passes when it moved on every frame the control
+a dialog they still wait for the backdrop's. Track a top-layer control from
+the same screencast with `trackControl(page, frames)` (`trackMarker` with
+`CONTROL_RGB`, searching only the top strip it crosses). A control mounted
+`within` a dialog moves with it, so track that one with `trackMarker(page,
+frames, {rgb: CONTROL_RGB})`. Pass either as `control`: the component passes when it moved on every frame the control
moved and its longest stall is no longer than the control's. Both are read from
the same screencast frames, so a compositor animation misses none. A window in
which the control moved on fewer than four frames fails, since the machine
@@ -245,6 +247,13 @@ is read from the value's changes in the judged part, so a position the page
commits off the grid once the block ends does not shrink it.
A main-thread animation still fails: the control moves and it does not.
+`controlClock(control)` reads the compositor's own time in each frame off the
+control's position, for a proof that judges motion against time, not against
+the screencast's stamps. A loaded machine stamps frames late, and
+`inPresentationOrder` can then put a frame after frames that came after it.
+The clock takes the cycle origin that most frames agree with, so such a frame
+moves only its own reading. A frame within 36 px of a turn gets no reading.
+
An animation that lasts a fraction of a second, such as a 0.2 s fade, leaves a
block only a few frames to judge: in WebKit, or on a loaded machine, the control
can present fewer than four, and one run cannot decide. Play it several times
diff --git a/internal/interaction-harness/src/busy.clock.test.ts b/internal/interaction-harness/src/busy.clock.test.ts
new file mode 100644
index 0000000000..8a431edd36
--- /dev/null
+++ b/internal/interaction-harness/src/busy.clock.test.ts
@@ -0,0 +1,161 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file busy.clock.test.ts
+ * @input Synthetic control frames (no browser)
+ * @output The control's clock. Its readings follow the control's animation
+ * time across turns and gaps, whatever the stamps say, also for frames
+ * stamped late and put out of order. A frame near a turn, or one that
+ * repeats the position before it, gets no reading. Includes the cases of
+ * the animator spec's former clock.
+ * @position Unit test of ./busy's controlClock
+ */
+
+import {describe, expect, it} from 'vitest';
+import {controlClock} from './busy';
+import {inPresentationOrder, type TrackedFrame} from './frames';
+
+const FRAME = 1000 / 60;
+
+/** The control's x at animation time `ms`: 240 px one way every 400 ms. */
+function xAt(ms: number): number {
+ const leg = Math.floor(ms / 400);
+ const along = ((ms % 400) / 400) * 240;
+ return leg % 2 === 0 ? along : 240 - along;
+}
+
+/** One frame per animation time in `times`, stamped `late(i)` ms after it. */
+function control(
+ times: readonly number[],
+ late: (i: number) => number = () => 0,
+): TrackedFrame[] {
+ return times.map((ms, i) => ({
+ t: 5000 + ms + late(i),
+ box: {x: xAt(ms), y: 0, width: 12, height: 12},
+ pixels: 144,
+ }));
+}
+
+/** Animation times one frame apart, from `from` to `to`. */
+function frameTimes(from: number, to: number): number[] {
+ const out: number[] = [];
+ for (let ms = from; ms <= to; ms += FRAME) {
+ out.push(ms);
+ }
+ return out;
+}
+
+/** Each frame's animation time, by its stamp (frames as `control` made them). */
+function timesByStamp(
+ times: readonly number[],
+ frames: readonly TrackedFrame[],
+): Map<number, number> {
+ return new Map(frames.map((frame, i) => [frame.t, times[i]]));
+}
+
+/**
+ * Expects every reading to equal its frame's animation time, both measured
+ * from the earliest frame read, and returns the readings.
+ */
+function expectAnimationTimes(
+ clock: Map<number, number>,
+ times: Map<number, number>,
+): {ms: number; at: number}[] {
+ const read = [...clock].map(([t, at]) => ({ms: times.get(t) ?? NaN, at}));
+ read.sort((a, b) => a.ms - b.ms);
+ for (const reading of read) {
+ expect(reading.at - read[0].at).toBeCloseTo(reading.ms - read[0].ms, 6);
+ }
+ return read;
+}
+
+describe('controlClock', () => {
+ it('reads the animation time across turns, whatever the stamps say', () => {
+ // Three turns, at 400, 800 and 1200 ms; every other frame stamped 12 ms
+ // late, as a loaded machine presents them.
+ const times = frameTimes(250, 1450);
+ const frames = control(times, i => (i % 2) * 12);
+ const clock = controlClock(frames);
+ expectAnimationTimes(clock, timesByStamp(times, frames));
+ // Every frame at least 36 px from both ends is read, and no other.
+ for (const frame of frames) {
+ const x = frame.box?.x ?? -1;
+ expect(clock.has(frame.t)).toBe(x >= 36 && x <= 204);
+ }
+ });
+
+ it('gives no reading to a frame near a turn', () => {
+ // The turn is at 400 ms. At 360 and 410 ms the box is 24 and 6 px from
+ // the end, where the two times that its position gives are close.
+ const frames = control([300, 360, 410, 470]);
+ const clock = controlClock(frames);
+ expect(clock.has(frames[1].t)).toBe(false);
+ expect(clock.has(frames[2].t)).toBe(false);
+ expect(clock.get(frames[3].t)! - clock.get(frames[0].t)!).toBeCloseTo(
+ 170,
+ 6,
+ );
+ });
+
+ it('reads across a gap of a whole leg or more', () => {
+ const times = [100, 120, 540, 560, 1300];
+ const frames = control(times);
+ const read = expectAnimationTimes(
+ controlClock(frames),
+ timesByStamp(times, frames),
+ );
+ expect(read).toHaveLength(times.length);
+ });
+
+ it('reads late frames that inPresentationOrder put out of order at their own time', () => {
+ // Frames one frame apart across the turn at 400 ms. Their stamps run 20
+ // to 50 ms late in turn, so a frame can land after later frames.
+ const times = frameTimes(50, 750);
+ const late = [0, 45, 22, 0, 30, 50, 0, 20];
+ const made = control(times, i => late[i % late.length]);
+ const byStamp = timesByStamp(times, made);
+ const frames = inPresentationOrder(made);
+ // The stamps did reorder the frames.
+ expect(
+ frames.some(
+ (frame, i) =>
+ i > 0 && byStamp.get(frame.t)! < byStamp.get(frames[i - 1].t)!,
+ ),
+ ).toBe(true);
+ const read = expectAnimationTimes(controlClock(frames), byStamp);
+ expect(read.length).toBeGreaterThan(frames.length / 2);
+ });
+
+ it('reads the first usable frame and the next one right when a turn lies between them', () => {
+ // At 338.3 ms the box is at 203 px on its way out, just inside the band.
+ // The frames after it sit within 36 px of the end until 466.3 ms. There
+ // the next usable frame is at 200.2 px, on its way back.
+ const times = Array.from({length: 60}, (_, i) => 338 + 1 / 3 + i * 16);
+ const frames = control(times);
+ const clock = controlClock(frames);
+ expect(clock.has(frames[0].t)).toBe(true);
+ expect(frames.slice(1, 8).some(frame => clock.has(frame.t))).toBe(false);
+ expect(clock.has(frames[8].t)).toBe(true);
+ expectAnimationTimes(clock, timesByStamp(times, frames));
+ });
+
+ it('reads every frame at its own time when the first frame is stamped 50 ms late', () => {
+ // The late first frame does not set the origin, so it moves no reading.
+ const times = Array.from({length: 60}, (_, i) => 100 + i * 16);
+ const frames = control(times, i => (i === 0 ? 50 : 0));
+ const clock = controlClock(frames);
+ expect(clock.has(frames[0].t)).toBe(true);
+ expectAnimationTimes(clock, timesByStamp(times, frames));
+ });
+
+ it('gives no reading to a frame that repeats the position before it', () => {
+ // The second frame shows the first frame's position, stamped a frame later.
+ const frames = control([100, 100, 150], i => (i === 1 ? FRAME : 0));
+ const clock = controlClock(frames);
+ expect(clock.has(frames[1].t)).toBe(false);
+ expect(clock.get(frames[2].t)! - clock.get(frames[0].t)!).toBeCloseTo(
+ 50,
+ 6,
+ );
+ });
+});
diff --git a/internal/interaction-harness/src/busy.ts b/internal/interaction-harness/src/busy.ts
index 58a20bf66a..4aeb24e04f 100644
--- a/internal/interaction-harness/src/busy.ts
+++ b/internal/interaction-harness/src/busy.ts
@@ -11,6 +11,8 @@
* read from its frames, `pooledBusyProof`, which judges several short
* blocks as one, and `BusyWindowTooLateError`, for a block that began
* after the motion it was meant to catch had ended.
+ * `trackControl` and `controlClock` read the control's box and its own
+ * clock from the screencast.
* @position The busy-main-thread proof: an animation that runs on the
* compositor keeps advancing at display rate while JavaScript holds the main
* thread; one driven from the main thread (rAF, style writes, layout
@@ -22,14 +24,45 @@
import type {Locator, Page} from '@playwright/test';
import {defineCurveEnd} from './curve-end';
-import {frameStats, type FrameStats, type TrackedFrame} from './frames';
+import {
+ frameStats,
+ trackMarker,
+ type CastFrame,
+ type FrameStats,
+ type TrackedFrame,
+} from './frames';
/** The control's colour, apart from the component's marker (`MARKER_RGB`). */
export const CONTROL_RGB: readonly [number, number, number] = [0, 255, 255];
-/** The control box's side, and how far it travels along the top edge, CSS px. */
-const CONTROL_SIDE = 12;
+/**
+ * The control box's side, CSS px: it crosses the page's top `CONTROL_SIDE` px,
+ * where a proof reads nothing of the component.
+ */
+export const CONTROL_SIDE = 12;
+/** How far the control travels along the top edge, CSS px. */
const CONTROL_TRAVEL = 240;
+/** How long the control takes to travel `CONTROL_TRAVEL` one way, ms. */
+const CONTROL_LEG_MS = 400;
+
+/**
+ * The control in each frame (`startBusyControl`'s box): `trackMarker` with
+ * `CONTROL_RGB`, searching only the strip the box crosses.
+ */
+export async function trackControl(
+ page: Page,
+ frames: readonly CastFrame[],
+): Promise<TrackedFrame[]> {
+ return trackMarker(page, frames, {
+ rgb: CONTROL_RGB,
+ region: {
+ x: 0,
+ y: 0,
+ width: CONTROL_SIDE + CONTROL_TRAVEL + 4,
+ height: CONTROL_SIDE + 4,
+ },
+ });
+}
/**
* Starts a plain compositor-only control animation: a `CONTROL_RGB` box in the
@@ -70,7 +103,7 @@ export async function startBusyControl(
);
}
await page.evaluate(
- ({color, side, travel}) =>
+ ({color, side, travel, legMs}) =>
new Promise<void>((resolve, reject) => {
const host = document.querySelector('[data-harness-control-host]');
host?.removeAttribute('data-harness-control-host');
@@ -90,7 +123,7 @@ export async function startBusyControl(
{transform: `translateX(${travel}px)`},
],
{
- duration: 400,
+ duration: legMs,
iterations: Infinity,
direction: 'alternate',
easing: 'linear',
@@ -131,7 +164,12 @@ export async function startBusyControl(
};
frame(tick);
}),
- {color: [...rgb], side: CONTROL_SIDE, travel: CONTROL_TRAVEL},
+ {
+ color: [...rgb],
+ side: CONTROL_SIDE,
+ travel: CONTROL_TRAVEL,
+ legMs: CONTROL_LEG_MS,
+ },
);
return {
raise: () =>
@@ -152,6 +190,94 @@ export async function startBusyControl(
};
}
+/** How far a frame's stamp may run late and still agree with the others, ms. */
+const CONTROL_AGREE_MS = 20;
+/**
+ * Frames this near a turn get no reading. There the two times that a position
+ * gives are under 120 ms apart, and a stamp 60 ms late could pick either.
+ */
+const CONTROL_EDGE = 36;
+
+/**
+ * The compositor's clock in each frame of `control` (`startBusyControl`'s box,
+ * tracked with `trackControl`), ms. The compositor samples every animation at
+ * one time in a frame. So a component can be judged against this clock, not
+ * the screencast's stamps. A loaded machine can stamp a frame late, and
+ * `inPresentationOrder` then puts it after frames that it came before.
+ *
+ * The box's position gives two times a cycle, on the way out and on the way
+ * back. The cycle's origin is the one that the most frames agree with, each
+ * within `CONTROL_AGREE_MS` of one of its two times. So no single frame sets
+ * it. Each frame's stamp, measured from that origin, then picks its own time.
+ * A late or reordered frame moves only its own reading, and a gap moves none.
+ *
+ * A frame without the box gets no reading, and so does a frame within
+ * `CONTROL_EDGE` px of a turn. A frame that repeats the position before it
+ * shows no new time, so it gets none either. Readings count up from the
+ * origin a whole cycle or less before the first reading.
+ */
+export function controlClock(
+ control: readonly TrackedFrame[],
+): Map<number, number> {
+ const cycle = 2 * CONTROL_LEG_MS;
+ const usable = control.flatMap((frame, i) => {
+ const x = frame.box?.x;
+ const before = i > 0 ? control[i - 1].box?.x : undefined;
+ if (
+ x == null ||
+ x < CONTROL_EDGE ||
+ x > CONTROL_TRAVEL - CONTROL_EDGE ||
+ (before != null && Math.abs(x - before) <= 0.25)
+ ) {
+ return [];
+ }
+ const out = (x / CONTROL_TRAVEL) * CONTROL_LEG_MS;
+ return [{t: frame.t, out, back: cycle - out}];
+ });
+ const clock = new Map<number, number>();
+ if (usable.length === 0) {
+ return clock;
+ }
+ const onCycle = (a: number, b: number) => {
+ const d = Math.abs(a - b) % cycle;
+ return Math.min(d, cycle - d);
+ };
+ let origin = 0;
+ let agreeing = -1;
+ let spread = Number.POSITIVE_INFINITY;
+ for (let candidate = 0; candidate < cycle; candidate += 1) {
+ let count = 0;
+ let sum = 0;
+ for (const frame of usable) {
+ const phase = frame.t - candidate;
+ const d = Math.min(onCycle(phase, frame.out), onCycle(phase, frame.back));
+ if (d <= CONTROL_AGREE_MS) {
+ count += 1;
+ sum += d;
+ }
+ }
+ if (count > agreeing || (count === agreeing && sum < spread)) {
+ origin = candidate;
+ agreeing = count;
+ spread = sum;
+ }
+ }
+ const first = Math.min(...usable.map(frame => frame.t));
+ const anchored = origin + Math.floor((first - origin) / cycle) * cycle;
+ for (const frame of usable) {
+ const expected = frame.t - anchored;
+ const nearest = (ms: number) =>
+ ms + Math.round((expected - ms) / cycle) * cycle;
+ const out = nearest(frame.out);
+ const back = nearest(frame.back);
+ clock.set(
+ frame.t,
+ Math.abs(out - expected) <= Math.abs(back - expected) ? out : back,
+ );
+ }
+ return clock;
+}
+
/** What the control presented in the judged part (see `busyWindowProof`). */
export interface BusyControlRead {
/** Frames in the judged part that presented a new control position. */
diff --git a/internal/interaction-harness/src/frames.ts b/internal/interaction-harness/src/frames.ts
index 95ef1af5d6..bf61f337f8 100644
--- a/internal/interaction-harness/src/frames.ts
+++ b/internal/interaction-harness/src/frames.ts
@@ -353,6 +353,8 @@ export function colorBlockPx(
/**
* Finds the marker in every frame. Decoding runs in a scratch page of the same
* browser, so neither the page under test nor Node needs an image decoder.
+ * With `region` (CSS px), only that part of each frame is searched. On a
+ * loaded machine, a search of every pixel can take longer than the test.
*/
export async function trackMarker(
page: Page,
@@ -360,7 +362,12 @@ export async function trackMarker(
{
rgb = MARKER_RGB,
tolerance = 40,
- }: {rgb?: readonly [number, number, number]; tolerance?: number} = {},
+ region,
+ }: {
+ rgb?: readonly [number, number, number];
+ tolerance?: number;
+ region?: Box;
+ } = {},
): Promise<TrackedFrame[]> {
const isDefaultMarker = rgb.every((value, i) => value === MARKER_RGB[i]);
const scratch = await page.context().newPage();
@@ -370,7 +377,7 @@ export async function trackMarker(
for (let i = 0; i < frames.length; i += 12) {
const batch = frames.slice(i, i + 12);
const boxes = await scratch.evaluate(
- async ({batch: items, color, tol}) => {
+ async ({batch: items, color, tol, area}) => {
const results: {
box: {x: number; y: number; width: number; height: number} | null;
pixels: number;
@@ -387,11 +394,28 @@ export async function trackMarker(
throw new Error('no 2d context');
}
context.drawImage(bitmap, 0, 0);
+ const scale = bitmap.width / item.viewportWidth;
+ const left = area == null ? 0 : Math.floor(area.x * scale);
+ const top = area == null ? 0 : Math.floor(area.y * scale);
+ const right =
+ area == null
+ ? bitmap.width
+ : Math.min(
+ bitmap.width,
+ Math.ceil((area.x + area.width) * scale),
+ );
+ const bottom =
+ area == null
+ ? bitmap.height
+ : Math.min(
+ bitmap.height,
+ Math.ceil((area.y + area.height) * scale),
+ );
const {data, width, height} = context.getImageData(
- 0,
- 0,
- bitmap.width,
- bitmap.height,
+ left,
+ top,
+ right - left,
+ bottom - top,
);
let minX = Infinity;
let minY = Infinity;
@@ -422,14 +446,13 @@ export async function trackMarker(
}
}
}
- const scale = width / item.viewportWidth;
results.push({
box:
pixels === 0
? null
: {
- x: minX / scale,
- y: minY / scale,
+ x: (left + minX) / scale,
+ y: (top + minY) / scale,
width: (maxX - minX + 1) / scale,
height: (maxY - minY + 1) / scale,
},
@@ -447,6 +470,7 @@ export async function trackMarker(
})),
color: [...rgb],
tol: tolerance,
+ area: region ?? null,
},
);
boxes.forEach((result, k) => {
diff --git a/packages/core/src/motion/__tests__/animator.interaction.browser.spec.ts b/packages/core/src/motion/__tests__/animator.interaction.browser.spec.ts
index 33aaf74b9d..cd61062852 100644
--- a/packages/core/src/motion/__tests__/animator.interaction.browser.spec.ts
+++ b/packages/core/src/motion/__tests__/animator.interaction.browser.spec.ts
@@ -27,6 +27,7 @@ import {
type BlockedWindow,
busyWindowProof,
CONTROL_RGB,
+ controlClock,
countBetween,
markElement,
startBusyControl,
@@ -38,7 +39,6 @@ import {expect, test, type Page} from '@astryxdesign/a11y-spec/playwright';
import {build} from 'esbuild';
import type {Animator, MotionHandle} from '../animator';
import type * as MotionBundle from './motionBundle';
-import {controlClock} from './controlClock';
let script = '';
@@ -221,18 +221,17 @@ test('a spring keeps advancing every frame through a 1 s main-thread block, on i
},
);
const [curve, faster] = curveMs;
- const controlAt = new Map(
- control.flatMap(f => (f.box == null ? [] : [[f.t, f.box.x] as const])),
- );
// The control's own time at each frame (controlClock): 240 px out in
// 400 ms, back in 400 ms, read from its position on the origin most frames
// agree with, so no one frame's stamp or direction sets it.
- const clock = controlClock(
- inside.map(f => ({t: f.t, x: controlAt.get(f.t) ?? null})),
- );
+ const clock = controlClock(control);
+ const timed = inside.flatMap((f, i) => {
+ const ms = clock.get(f.t);
+ return ms == null ? [] : [{i, ms}];
+ });
/** How far the box's curve time drifts from the control's, ms. */
const drift = (times: number[]) => {
- const gaps = clock.map(({i, ms}) => times[i] - ms).sort((x, y) => x - y);
+ const gaps = timed.map(({i, ms}) => times[i] - ms).sort((x, y) => x - y);
return (
gaps[Math.floor(gaps.length * 0.9)] - gaps[Math.floor(gaps.length * 0.1)]
);
@@ -246,7 +245,7 @@ test('a spring keeps advancing every frame through a 1 s main-thread block, on i
sorted[Math.floor(sorted.length * 0.9)] -
sorted[Math.floor(sorted.length * 0.1)];
const read = {
- frames: clock.length,
+ frames: timed.length,
drift: drift(curve),
faster: drift(faster),
median,
@@ -258,7 +257,7 @@ test('a spring keeps advancing every frame through a 1 s main-thread block, on i
});
// Placed on its curve and on the control's, every frame is the same time
// apart, to within the 1 px steps of both; a spring 10% off drifts.
- expect(clock.length, JSON.stringify(read)).toBeGreaterThan(20);
+ expect(timed.length, JSON.stringify(read)).toBeGreaterThan(20);
expect(read.drift, JSON.stringify(read)).toBeLessThan(12);
expect(read.faster, JSON.stringify(read)).toBeGreaterThan(24);
if (browserName === 'chromium') {
diff --git a/packages/core/src/motion/__tests__/controlClock.test.ts b/packages/core/src/motion/__tests__/controlClock.test.ts
deleted file mode 100644
index ce26cbb48d..0000000000
--- a/packages/core/src/motion/__tests__/controlClock.test.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {controlClock} from './controlClock';
-
-/** The control's x at its own time `ms`: 240 px out in 400 ms, back in 400. */
-function controlX(ms: number): number {
- const phase = ((ms % 800) + 800) % 800;
- return phase < 400 ? phase * 0.6 : 240 - (phase - 400) * 0.6;
-}
-
-/**
- * Frames 16 ms apart from the control's time `from`, stamped on a clock
- * `offset` ms ahead of it; `late` adds lateness to chosen frames' stamps.
- */
-function frames(
- from: number,
- count: number,
- offset: number,
- late: ReadonlyMap<number, number> = new Map(),
-) {
- return Array.from({length: count}, (_, i) => {
- const ms = from + i * 16;
- return {t: ms + offset + (late.get(i) ?? 0), x: controlX(ms), ms};
- });
-}
-
-/** How far each reading strays from the control's true time, past a constant. */
-function strays(
- run: ReadonlyArray<{ms: number}>,
- clock: ReadonlyArray<{i: number; ms: number}>,
-): number {
- const gaps = clock.map(({i, ms}) => ms - run[i].ms).sort((a, b) => a - b);
- return gaps[gaps.length - 1] - gaps[0];
-}
-
-describe('controlClock', () => {
- it('reads every frame on the control’s own time on an even run', () => {
- const run = frames(100, 60, 5_000);
- const clock = controlClock(run);
- expect(clock.length).toBeGreaterThan(40);
- expect(strays(run, clock)).toBeLessThan(1e-6);
- });
-
- it('reads every frame right when the first usable frame sits just inside the band on its way out and the next usable one comes after the turn', () => {
- // x 214 on the way out (356.7 ms); the frames until 452.7 ms sit above
- // the band, and the next usable one, at 208.4, is on the way back.
- const run = frames(356 + 2 / 3, 60, 5_000);
- const clock = controlClock(run);
- expect(strays(run, clock)).toBeLessThan(1e-6);
- });
-
- it('reads every other frame right when the first usable frame is stamped 50 ms late', () => {
- const run = frames(100, 60, 5_000, new Map([[0, 50]]));
- const clock = controlClock(run).filter(({i}) => i !== 0);
- expect(strays(run, clock)).toBeLessThan(1e-6);
- });
-});
diff --git a/packages/core/src/motion/__tests__/controlClock.ts b/packages/core/src/motion/__tests__/controlClock.ts
deleted file mode 100644
index 641dd7e479..0000000000
--- a/packages/core/src/motion/__tests__/controlClock.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file controlClock.ts
- * @input Screencast frames: each one's timestamp and the harness's control
- * box's x on it (240 px out in 400 ms, back in 400 ms, repeating)
- * @output Exports controlClock: the control's own time at each usable frame
- * @position Test support for animator.interaction.browser.spec.ts, whose
- * busy-window proof reads the spring against the control's clock
- */
-
-/** The control's speed, px per ms: 240 px in 400 ms. */
-const SPEED = 0.6;
-/** One out-and-back, ms. */
-const CYCLE = 800;
-/**
- * Frames this near a turn are left out: there the two times a position
- * gives are under 80 ms apart.
- */
-const EDGE = 24;
-
-export interface ClockFrame {
- readonly t: number;
- readonly x: number | null;
-}
-
-/** How far a frame's stamp may run late and still agree with the others, ms. */
-const AGREE = 20;
-
-/** The distance between two times on the cycle, ms. */
-function onCycle(a: number, b: number): number {
- const d = Math.abs(a - b) % CYCLE;
- return Math.min(d, CYCLE - d);
-}
-
-/**
- * The control's time at each usable frame, by index into `frames`. Its
- * position gives two times a cycle, on the way out and on the way back. The
- * cycle's origin is the one the most frames agree with, each within AGREE ms
- * of one of its two times, so no single frame sets it: a frame whose stamp
- * runs late, or one whose direction its neighbors cannot tell (the next
- * usable frame past a turn), moves only its own reading. Each frame's
- * timestamp, measured from that origin, then picks its time.
- */
-export function controlClock(
- frames: ReadonlyArray<ClockFrame>,
-): {i: number; ms: number}[] {
- const usable = frames.flatMap((f, i) =>
- f.x == null || f.x < EDGE || f.x > 240 - EDGE
- ? []
- : [{i, t: f.t, out: f.x / SPEED, back: CYCLE - f.x / SPEED}],
- );
- if (usable.length === 0) {
- return [];
- }
- let origin = 0;
- let agreeing = -1;
- let spread = Number.POSITIVE_INFINITY;
- for (let candidate = 0; candidate < CYCLE; candidate++) {
- let count = 0;
- let sum = 0;
- for (const u of usable) {
- const phase = u.t - candidate;
- const d = Math.min(onCycle(phase, u.out), onCycle(phase, u.back));
- if (d <= AGREE) {
- count += 1;
- sum += d;
- }
- }
- if (count > agreeing || (count === agreeing && sum < spread)) {
- origin = candidate;
- agreeing = count;
- spread = sum;
- }
- }
- // The same origin a whole number of cycles before the first frame, so the
- // control's times count up from it.
- const first = usable[0].t;
- const anchored = origin + Math.floor((first - origin) / CYCLE) * CYCLE;
- return usable.map(u => {
- const expected = u.t - anchored;
- const cycle = Math.round((expected - u.out) / CYCLE);
- const candidates = [u.out, u.back, u.out + CYCLE, u.back - CYCLE].map(
- ms => ms + cycle * CYCLE,
- );
- const ms = candidates.reduce((best, c) =>
- Math.abs(c - expected) < Math.abs(best - expected) ? c : best,
- );
- return {i: u.i, ms};
- });
-}