Take the timeline commits back out before merging their reviewed versions from main

5150279cc, 97bd61711, 900c76425 and 4f23ad330 went to main, reviewed and
changed, as #1745. They are taken out here so main brings them in as
merged, rather than as two copies of the same changes in conflict.
This commit is contained in:
Sameh Khamis committed 2026-11-14 21:52:58 -08:00
1 parent 4f23ad330c
commit 961e6321a5
45 files changed
+1316 -1078

No files matched your search

-24
View File
@@ -1,6 +1,5 @@
import { fromDegrees } from '../../geo/ellipsoid.js';
import { drawOf } from '../../render/rendererOf.js';
import { worldClock } from '../../time/worldClock.js';
import {
EARTHQUAKE_OVERLAY_SOURCE_ID,
EARTHQUAKE_OVERLAY_COHORT_LIMIT,
@@ -10,7 +9,6 @@ import {
createEarthquakeOverlayEntry,
selectEarthquakeOverlayCohort,
mapAnalystRecord,
earthquakeCoverage,
} from './model.js';
export * from './model.js';
export { createUsgsEarthquakeSource } from './source.js';
@@ -47,18 +45,6 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) {
let _lastUpdate = null;
let _lastError = null;
let _enabled = false;
let _uncover = null;
// The marks last told to the clock, so a refresh with the same strong
// quakes does not tell it again.
let _marksKey = null;
const coverage = () => (_enabled ? earthquakeCoverage(_events) : null);
const coverageChanged = () => {
const covered = coverage();
const key = covered ? JSON.stringify(covered.marks) : null;
if (key === _marksKey) return;
_marksKey = key;
worldClock.coverageChanged();
};
const layer = {
id: 'earthquakes',
@@ -74,10 +60,6 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) {
show: false,
});
_viewer = viewer;
// While on, the strong quakes are marks on the world clock's timeline.
// Registered once; off, the layer has no time to show.
_marksKey = null;
_uncover = worldClock.register({ id: 'earthquakes', coverage });
_count = 0;
_lastUpdate = null;
_lastError = null;
@@ -92,7 +74,6 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) {
// layer has no per-frame animator to keep the render loop alive for.
if (_discs) _discs.show = true;
overlayHost.setVisible(EARTHQUAKE_OVERLAY_SOURCE_ID, true);
coverageChanged();
},
disable(viewer) {
@@ -102,7 +83,6 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) {
if (_discs) _discs.show = false;
overlayHost.clearSource(EARTHQUAKE_OVERLAY_SOURCE_ID);
overlayHost.setVisible(EARTHQUAKE_OVERLAY_SOURCE_ID, false);
coverageChanged();
},
async update(viewer) {
@@ -166,7 +146,6 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) {
_discs.set(nextDiscs);
_events = nextEvents;
coverageChanged();
if (_enabled) {
overlayHost.setEntries(
EARTHQUAKE_OVERLAY_SOURCE_ID,
@@ -205,9 +184,6 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) {
_discs?.dispose();
_discs = null;
_events = [];
_uncover?.();
_uncover = null;
_marksKey = null;
_count = 0;
_lastUpdate = null;
_lastError = null;
+1 -59
View File
@@ -2,64 +2,6 @@ export const EARTHQUAKE_OVERLAY_SOURCE_ID = 'earthquakes';
export const EARTHQUAKE_OVERLAY_COHORT_LIMIT = 96;
export const EARTHQUAKE_OVERLAY_COLLISION_CAPACITY = 48;
/**
* The smallest magnitude the timeline marks. Most quakes are small shakes;
* M6 and up come about once every two days worldwide, so each is an event
* worth stepping to. The map still draws every quake.
*/
export const EARTHQUAKE_MARK_MAGNITUDE = 6;
/** The longest place a timeline mark's label carries, ellipsis and all. */
const MARK_PLACE_LENGTH = 40;
/** A magnitude as the map's labels show it: `M6.4`. */
export const earthquakeMagnitudeTitle = (magnitude) =>
`M${Number(magnitude).toFixed(1)}`;
/**
* A strong quake's timeline label: its magnitude and, where the feed names
* one, its place, cut short (`M6.4 · 113 km SSE of Lata, Solomon Islands`).
* @param {{mag: number, place?: string | null}} event
* @returns {string}
*/
export function earthquakeMarkLabel({ mag, place }) {
const title = earthquakeMagnitudeTitle(mag);
const where =
typeof place === 'string' ? place.replace(/\s+/g, ' ').trim() : '';
if (!where) return title;
const short =
where.length > MARK_PLACE_LENGTH
? `${where.slice(0, MARK_PLACE_LENGTH - 1).trimEnd()}…`
: where;
return `${title} · ${short}`;
}
/**
* The time a world clock's timeline can show for `events` (`{mag, time,
* place?, usgsId?}`, time in ms): the span of the quakes of
* EARTHQUAKE_MARK_MAGNITUDE and up, each one a mark labelled with its
* magnitude and place, or null with none, so the layer never stretches the
* timeline past what its feed covers.
* @returns {{start: number, end: number, marks: Array<{time: number, label: string, id?: string, kind: string}>} | null}
*/
export function earthquakeCoverage(events) {
const marks = events
.filter(
({ mag, time }) =>
mag >= EARTHQUAKE_MARK_MAGNITUDE && Number.isFinite(time),
)
.map((event) => ({
time: event.time,
label: earthquakeMarkLabel(event),
...(event.usgsId ? { id: String(event.usgsId) } : {}),
kind: 'earthquake',
}))
.sort((a, b) => a.time - b.time);
return marks.length
? { start: marks[0].time, end: marks.at(-1).time, marks }
: null;
}
// The depth bands' colours: CSS red, orange and yellow, as the renderer's
// colour tuples (`[r, g, b, a]`, 0..1) and as CSS for the labels' accent.
const SHALLOW = Object.freeze({ rgba: [1, 0, 0, 1], css: 'rgb(255,0,0)' });
@@ -108,7 +50,7 @@ export function createEarthquakeOverlayEntry({
id: String(id),
position,
variant: 'label',
title: earthquakeMagnitudeTitle(mag),
title: `M${mag.toFixed(1)}`,
accent,
priority: Math.round(mag * 1000),
collisionGroup: 'ambient-label',
-70
View File
@@ -2,8 +2,6 @@ import assert from 'node:assert/strict';
import test from 'node:test';
import { createEarthquakesLayer } from './index.js';
import { createUsgsEarthquakeSource } from './source.js';
import { EARTHQUAKE_MARK_MAGNITUDE, earthquakeMarkLabel } from './model.js';
import { worldClock } from '../../time/worldClock.js';
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
function harness(source) {
const events = [];
@@ -170,71 +168,3 @@ test('a viewer with nothing to draw with is refused at init, and init can be ret
layer.destroy();
unbind();
});
test('the timeline marks only strong quakes, while the layer is on', async () => {
assert.equal(EARTHQUAKE_MARK_MAGNITUDE, 6);
const rows = [
{ ...row, stableId: 'small', mag: 4.5, time: 1_000 },
{ ...row, stableId: 'strong', usgsId: 'us-strong', mag: 6, time: 5_000 },
{
...row,
stableId: 'great',
usgsId: 'us-great',
mag: 7.2,
place: ' 113 km SSE of Lata, Solomon Islands region of the Pacific ',
time: 3_000,
},
{ ...row, stableId: 'untimed', mag: 6.5, time: null },
];
let snapshot = rows;
const h = harness({ getSnapshot: async () => snapshot });
assert.equal(worldClock.coverage(), null, 'nothing loaded, no time to show');
let changes = 0;
const unsubscribe = worldClock.subscribe(() => changes++);
await h.layer.update(h.viewer);
// Every quake is drawn; only M6 and up are marks, spanning their own time.
assert.equal(h.draw.find('earthquakes:').items.size, 4);
// Each labelled with its magnitude and, cut short, its place.
assert.deepEqual(worldClock.coverage(), {
start: 3_000,
end: 5_000,
marks: [3_000, 5_000],
markDetails: [
{
time: 3_000,
label: 'M7.2 · 113 km SSE of Lata, Solomon Islands reg…',
id: 'us-great',
kind: 'earthquake',
},
{
time: 5_000,
label: 'M6.0 · Fixture',
id: 'us-strong',
kind: 'earthquake',
},
],
});
const told = changes;
await h.layer.update(h.viewer);
assert.equal(changes, told, 'the same strong quakes are not told again');
snapshot = rows.slice(0, 1);
await h.layer.update(h.viewer);
assert.equal(worldClock.coverage(), null, 'small shakes alone cover no time');
snapshot = rows;
await h.layer.update(h.viewer);
h.layer.disable(h.viewer);
assert.equal(worldClock.coverage(), null, 'off, no time to show');
h.layer.enable(h.viewer);
assert.deepEqual(worldClock.coverage().marks, [3_000, 5_000]);
h.layer.destroy();
assert.equal(worldClock.coverage(), null);
unsubscribe();
});
test('a strong quake with no place is labelled with its magnitude alone', () => {
assert.equal(earthquakeMarkLabel({ mag: 6.44, place: null }), 'M6.4');
assert.equal(earthquakeMarkLabel({ mag: 6, place: ' ' }), 'M6.0');
assert.equal(
earthquakeMarkLabel({ mag: 8.1, place: 'Off the coast' }),
'M8.1 · Off the coast',
);
});
+6 -21
View File
@@ -147,9 +147,6 @@ function restoreCameraView(viewer, view, landedView) {
camera.setView(view);
}
/** The longest name a timeline mark carries, as in the mission index. */
const MARK_LABEL_LENGTH = 27;
export function createLifecycle({
state: layerState,
services,
@@ -159,30 +156,18 @@ export function createLifecycle({
const { holdContinuousRender, releaseContinuousRender } = services.render;
let hover = null;
// While on, the launches loaded span the time from the first to the last,
// each one a mark labelled with its mission's name (the launch's where it
// has none), cut short and in capitals as the mission index shows names.
// Registered once; off, the layer has no time to show, and each step tells
// the clock once it has settled.
// each one a mark. Registered once; off, the layer has no time to show, and
// each step tells the clock once it has settled.
worldClock.register({
id: 'rocket-launches',
coverage: () => {
if (!layerState._enabled) return null;
const marks = layerState._launches
.map((launch) => ({
time: Date.parse(launch.launchTime),
label: parts.overlays
.shortMissionLabel(
launch.missionName || launch.name,
MARK_LABEL_LENGTH,
)
.toUpperCase(),
...(launch.id != null ? { id: String(launch.id) } : {}),
kind: 'launch',
}))
.filter(({ time }) => Number.isFinite(time))
.sort((a, b) => a.time - b.time);
.map((launch) => Date.parse(launch.launchTime))
.filter(Number.isFinite)
.sort((a, b) => a - b);
if (!marks.length) return null;
return { start: marks[0].time, end: marks.at(-1).time, marks };
return { start: marks[0], end: marks.at(-1), marks };
},
});
+154 -35
View File
@@ -59,15 +59,12 @@ export const PLAY_WAIT_MS = 8_000;
// costs play nothing.
let clocks = 0;
// How many weather clocks follow each world clock.
const followers = new WeakMap();
/**
* Transient observed time. Products must honor the signal before installing a
* frame. Its time is the world clock's: latest while the world is live,
* history at the world's time otherwise. It never moves the world clock
* itself; the world's own controls (its timeline) move time, and while the
* world plays it stops at each next frame until that frame loads.
* history at the world's time otherwise. Replay steps the observed frames and
* moves the world clock as it goes, as the world clock's driver.
*/
export function createWeatherClock({
now = Date.now,
@@ -79,10 +76,17 @@ export function createWeatherClock({
const listeners = new Set();
let mode = 'latest';
let target = null;
// The world time last applied.
let playing = false;
// The world time last applied; while this clock moves the world, the
// transition its move started.
let seen = 'latest';
let moving = false;
let moved = null;
const releases = new Map();
// Attached at the end, once the API exists.
let driver = null;
let generation = 0;
let timer = null;
let pending = null;
// This clock's name on the world, for its holds and its gate.
const holdId = `weather:${++clocks}`;
@@ -143,9 +147,10 @@ export function createWeatherClock({
const getState = () => ({
mode,
target,
// Frames come on one after another as the world plays on through them,
// so the next is worth loading ahead.
advancing: worldPlaysOn(),
playing,
// Frames come on one after another: this clock replays them, or the world
// plays on through them, so the next is worth loading ahead.
advancing: playing || worldPlaysOn(),
timeline: getTimeline(),
products: [...registry.values()].map(({ product }) => ({
id: product.id,
@@ -157,12 +162,60 @@ export function createWeatherClock({
const notify = () => {
if (!destroyed) for (const listener of listeners) listener(getState());
};
const cancelTimer = () => {
if (timer !== null) clearTimeout(timer);
timer = null;
};
const canPlay = () => getTimeline().length >= 2;
const stopPlaying = () => {
if (!playing) return;
playing = false;
driver?.driven(false);
};
// Move the world clock; the change comes back through followWorld. Returns
// the transition the move started, if it started one.
const move = (fn) => {
const outer = [moving, moved];
moving = true;
moved = null;
try {
fn();
return moved;
} finally {
[moving, moved] = outer;
}
};
const selections = () =>
[...registry.values()].map(({ product }) => selectedFor(product)).join();
let applied = null;
function schedule() {
cancelTimer();
if (!playing || destroyed || pending) return;
if (!canPlay()) {
stopPlaying();
notify();
return;
}
const owner = generation;
timer = setTimeout(() => {
timer = null;
if (destroyed || !playing || owner !== generation) return;
const timeline = getTimeline();
if (timeline.length < 2) {
api.pause();
return;
}
const next = timeline.find(
(time) => Date.parse(time) > Date.parse(target),
);
void api.setTarget(next ?? timeline[0]);
}, 2000);
}
function transition() {
if (destroyed) return Promise.resolve(false);
cancelTimer();
const owner = ++generation;
if (!canPlay()) stopPlaying();
// A scrub drops what loads and moves on; play goes on as this loads.
applied = selections();
deferred = false;
@@ -182,12 +235,15 @@ export function createWeatherClock({
if (destroyed || owner !== generation) return false;
stopWaiting();
pending = null;
if (!canPlay()) stopPlaying();
notify();
schedule();
// Play held at the next frame for this one goes on to it.
if (deferred) void transition();
return true;
});
pending = result;
if (moving) moved ??= result;
notify();
return result;
}
@@ -198,13 +254,11 @@ export function createWeatherClock({
throw new Error(`Duplicate weather product: ${product.id}`);
const entry = { product, controller: null };
registry.set(product.id, entry);
// The product moves with the world clock, and the span of its frames is
// time the world clock's timeline can show while it is on, suspended or
// not, so the way back to live stays on screen. The frames are not
// marks: they come every few minutes, and the timeline marks only
// events. Both calls notify the world's listeners, which may destroy
// this clock: the release is in place first, and anything acquired
// after a destroy is let go at once.
// The product moves with the world clock, and its frames are time the
// world clock's timeline can show while it is on, suspended or not, so
// the way back to live stays on screen. Both calls notify the world's
// listeners, which may destroy this clock: the release is in place
// first, and anything acquired after a destroy is let go at once.
let unhold = null;
let uncover = null;
const release = () => {
@@ -218,12 +272,9 @@ export function createWeatherClock({
uncover = world.register({
id: product.id,
coverage: () => {
const times = timesFor(product);
return times.length
? {
start: Date.parse(times[0]),
end: Date.parse(times.at(-1)),
}
const marks = timesFor(product).map((time) => Date.parse(time));
return marks.length
? { start: marks[0], end: marks.at(-1), marks }
: null;
},
});
@@ -249,17 +300,81 @@ export function createWeatherClock({
* wind, gives that layer the timeline time rather than the live edge.
*/
follows: (id) => world.follows(id),
/**
* The world clock this clock follows. Time moves there, through the same
* seek, play and live the world's timeline uses, never through this clock.
*/
world,
setTarget(time) {
if (destroyed) return Promise.resolve(false);
if (!Number.isFinite(Date.parse(time)))
throw new TypeError('Weather target must be a UTC time');
const normalized = new Date(time).toISOString();
if (mode === 'history' && target === normalized)
return pending ?? Promise.resolve(true);
return (
move(() => world.seek(Date.parse(normalized))) ??
pending ??
Promise.resolve(true)
);
},
step(direction) {
if (destroyed || ![-1, 1].includes(direction))
return Promise.resolve(false);
api.pause();
const timeline = getTimeline();
if (!timeline.length) return Promise.resolve(false);
const at = Date.parse(target ?? timeline.at(-1));
const next =
direction < 0
? (timeline.findLast((time) => Date.parse(time) < at) ?? timeline[0])
: (timeline.find((time) => Date.parse(time) > at) ?? timeline.at(-1));
return api.setTarget(next);
},
latest() {
if (destroyed) return Promise.resolve(false);
stopPlaying();
if (mode === 'latest') return transition();
return move(() => world.goLive()) ?? pending ?? Promise.resolve(true);
},
play() {
if (destroyed || playing || !canPlay())
return pending ?? Promise.resolve(false);
playing = true;
if (mode === 'latest') {
const timeline = getTimeline();
const start =
timeline.findLast((time) => Date.parse(time) <= now()) ?? timeline[0];
// Playing and at the first frame in one move of the world.
return (
move(() => driver.driven(true, Date.parse(start))) ??
pending ??
Promise.resolve(true)
);
}
driver.driven(true);
notify();
schedule();
return pending ?? Promise.resolve(true);
},
pause() {
cancelTimer();
if (!playing) {
// The world may be playing on its own; a pause or step here holds it.
if (world.isPlaying()) world.pause();
return;
}
stopPlaying();
notify();
},
togglePlay() {
return playing ? api.pause() : api.play();
},
refresh() {
if (destroyed) return Promise.resolve(false);
// New frames, or products added or dropped, and with them the next.
world.coverageChanged();
gated = undefined;
gateNext(world.getState());
if (!canPlay()) {
stopPlaying();
cancelTimer();
}
if (mode === 'history') return transition();
notify();
return Promise.resolve(true);
@@ -271,15 +386,15 @@ export function createWeatherClock({
},
destroy() {
if (destroyed) return;
stopPlaying();
destroyed = true;
++generation;
stopWaiting();
world.gate(holdId, null);
cancelTimer();
unfollowWorld();
// The last weather clock leaves the world live, as a new one expects.
const left = followers.get(world) - 1;
followers.set(world, left);
if (left === 0) world.goLive();
if (driver.detach() === 0) world.goLive();
for (const release of releases.values()) release();
releases.clear();
for (const entry of registry.values()) entry.controller?.abort();
@@ -288,8 +403,9 @@ export function createWeatherClock({
pending = null;
},
};
// Follow the world clock. A move (a seek, play going on) applies only when
// it changes the mode or a product's frame.
// Follow the world clock. A move of this clock's own always applies; one
// from elsewhere (a host's seek, continuous play) applies only when it
// changes the mode or a product's frame.
function followWorld(state) {
if (destroyed) return;
gateNext(state);
@@ -310,7 +426,7 @@ export function createWeatherClock({
const modeChanged = nextMode !== mode;
mode = nextMode;
target = nextTarget;
if (!modeChanged && selections() === applied) {
if (!moving && !modeChanged && selections() === applied) {
// Back at the frame that loads, play need not hold for it.
if (deferred) {
deferred = false;
@@ -323,7 +439,7 @@ export function createWeatherClock({
}
// Playing on into the next frame while the one before it loads, the
// world holds here until that one shows.
if (!modeChanged && pending && playsOn) {
if (!moving && !modeChanged && pending && playsOn) {
deferred = true;
startWaiting();
notify();
@@ -346,7 +462,10 @@ export function createWeatherClock({
world.gate(holdId, next);
}
const unfollowWorld = world.subscribe(followWorld);
followers.set(world, (followers.get(world) ?? 0) + 1);
driver = world.attachDriver({
play: () => (canPlay() ? void api.play() : false),
pause: () => api.pause(),
});
followWorld(world.getState());
return api;
}
+200 -74
View File
@@ -158,16 +158,13 @@ test('a product’s gap is at least one and a half of its feed’s frame spacing
assert.equal(clock.selectFor('clouds', time(211)), null);
});
const at = (minutes) => Date.parse(time(minutes));
test('history applies per-product selections, including null; live restores unequal newest times', async (t) => {
const { clock, world } = harness(t);
test('history applies per-product selections, including null; latest restores unequal newest times', async (t) => {
const { clock } = harness(t);
const radar = product('radar', [0, 10, 20]);
const satellite = product('satellite', [5, 15]);
const lightning = product('lightning', [15]);
for (const p of [radar, satellite, lightning]) clock.register(p);
world.seek(at(10));
await flush();
await clock.setTarget(time(10));
assert.deepEqual(
[radar.shown, satellite.shown, lightning.shown],
[time(10), time(5), null],
@@ -176,19 +173,18 @@ test('history applies per-product selections, including null; live restores uneq
clock.getState().products.map(({ selected }) => selected),
[time(10), time(5), null],
);
world.goLive();
await flush();
await clock.latest();
assert.deepEqual(
[radar.shown, satellite.shown, lightning.shown],
[time(20), time(15), time(15)],
);
assert.equal(clock.getState().mode, 'latest');
assert.equal(clock.getState().target, null);
assert.equal(clock.getState().advancing, false);
assert.equal(clock.getState().playing, false);
});
test('superseded completions cannot commit or notify', async (t) => {
const { clock, world, timers } = harness(t);
test('superseded completions cannot commit, notify or schedule a new playback advance', async (t) => {
const { clock, timers } = harness(t);
const p = product('radar', [0, 10, 20]);
const loads = [];
p.apply = (selected, { signal }) =>
@@ -205,44 +201,113 @@ test('superseded completions cannot commit or notify', async (t) => {
clock.register(p);
let notifications = 0;
clock.subscribe(() => notifications++);
world.seek(at(0));
const old = clock.setTarget(time(0));
await flush();
world.seek(at(10));
const current = clock.setTarget(time(10));
await flush();
assert.equal(loads[0].signal.aborted, true);
loads[1].finish();
await flush();
assert.equal(await current, true);
const count = notifications;
loads[0].finish();
await flush();
assert.equal(await old, false);
assert.equal(notifications, count);
assert.equal(p.shown, time(10));
assert.equal(clock.getState().target, time(10));
assert.equal(timers.size, 0);
});
test('the clock has no time controls of its own; the world clock moves time', (t) => {
const { clock, world } = harness(t);
for (const name of [
'setTarget',
'step',
'latest',
'play',
'pause',
'togglePlay',
])
assert.equal(clock[name], undefined, name);
assert.equal(clock.world, world);
test('steps use strict union neighbours from arbitrary targets and clamp at endpoints', async (t) => {
const { clock } = harness(t);
clock.register(product('radar', [0, 10, 20]));
clock.register(product('satellite', [5, 15]));
await clock.step(-1);
assert.equal(clock.getState().target, time(15));
await clock.setTarget(time(12));
await clock.step(-1);
assert.equal(clock.getState().target, time(10));
await clock.setTarget(time(12));
await clock.step(1);
assert.equal(clock.getState().target, time(15));
await clock.setTarget(time(0));
await clock.step(-1);
assert.equal(clock.getState().target, time(0));
await clock.setTarget(time(20));
await clock.step(1);
assert.equal(clock.getState().target, time(20));
});
test('playback waits for every product to settle, including rejection, then waits 2000 ms and wraps', async (t) => {
const { clock, tick, timers } = harness(t);
const a = product('radar', [0, 10]);
const b = product('satellite', [5]);
const loads = [];
b.apply = () =>
new Promise((resolve, reject) => loads.push({ resolve, reject }));
clock.register(a);
clock.register(b);
const start = clock.play();
await flush();
assert.equal(clock.getState().target, time(10));
tick(10_000);
assert.equal(timers.size, 0);
assert.equal(a.calls.length, 1);
loads[0].reject(new Error('unavailable'));
await start;
assert.equal(timers.size, 1);
tick(1999);
assert.equal(clock.getState().target, time(10));
tick(1);
await flush();
assert.equal(clock.getState().target, time(0));
assert.equal(timers.size, 0);
tick(10_000);
assert.equal(clock.getState().target, time(0));
loads[1].resolve(true);
await flush();
tick(2000);
await flush();
assert.equal(clock.getState().target, time(5));
clock.pause();
loads[2].resolve(false);
await flush();
assert.equal(timers.size, 0, 'pausing during a load prevents rescheduling');
});
test('pause cancels a pending advance; playback stops with one time or all products suspended', async (t) => {
const { clock, tick, timers } = harness(t);
const p = product('radar', [0, 10]);
clock.register(p);
await clock.play();
await clock.play();
assert.equal(timers.size, 1);
clock.pause();
tick(2000);
assert.equal(clock.getState().target, time(10));
assert.equal(timers.size, 0);
await clock.togglePlay();
p.times = [time(0)];
await clock.refresh();
assert.equal(clock.getState().playing, false);
await clock.play();
assert.equal(clock.getState().playing, false);
p.times = [time(0), time(10)];
await clock.refresh();
await clock.play();
p.suspended = true;
await clock.refresh();
assert.equal(clock.getState().playing, false);
assert.deepEqual(clock.getTimeline(), []);
assert.equal(timers.size, 0);
});
test('refresh does not apply in latest; history retains its target as expired frames disappear', async (t) => {
const { clock, world } = harness(t);
const { clock } = harness(t);
const p = product('radar', [0, 10]);
clock.register(p);
await clock.refresh();
assert.equal(p.calls.length, 0);
world.seek(at(10));
await flush();
await clock.setTarget(time(10));
p.times = [time(0), time(20)];
await clock.refresh();
assert.equal(p.shown, time(0));
@@ -253,16 +318,15 @@ test('refresh does not apply in latest; history retains its target as expired fr
});
test('registration joins history; unregister and destroy abort work and release subscriptions/timers', async (t) => {
const { clock, world, timers } = harness(t);
const { clock, timers, tick } = harness(t);
const p = product('radar', [0, 10]);
const unregister = clock.register(p);
world.seek(at(0));
await flush();
await clock.setTarget(time(0));
const b = product('satellite', [0, 5]);
clock.register(b);
await flush();
assert.equal(b.shown, time(0));
world.seek(at(5));
await clock.play();
unregister();
unregister();
await flush();
@@ -273,27 +337,31 @@ test('registration joins history; unregister and destroy abort work and release
);
let notifications = 0;
const off = clock.subscribe(() => notifications++);
clock.pause();
off();
world.seek(at(0));
await flush();
assert.equal(notifications, 0);
world.seek(at(5));
const before = notifications;
await clock.play();
assert.equal(notifications, before);
clock.destroy();
clock.destroy();
await flush();
tick(2000);
assert.equal(timers.size, 0);
assert.equal(b.calls.at(-1).signal.aborted, true);
assert.equal(clock.getState().playing, false);
assert.deepEqual(clock.getTimeline(), []);
assert.equal(await clock.setTarget(time(5)), false);
});
test('the weather time is the world time', async (t) => {
test('the weather time is the world time, both ways', async (t) => {
const { clock, world } = harness(t);
const radar = product('radar', [0, 10, 20]);
clock.register(radar);
assert.equal(world.follows('radar'), true);
world.seek(at(3));
await clock.setTarget(time(10));
assert.equal(world.isLive(), false);
assert.equal(world.now(), Date.parse(time(10)));
world.seek(Date.parse(time(3)));
await flush();
assert.equal(clock.getState().mode, 'history');
assert.equal(clock.getState().target, time(3));
assert.equal(radar.shown, time(0));
world.goLive();
@@ -302,22 +370,30 @@ test('the weather time is the world time', async (t) => {
assert.equal(radar.shown, time(20));
});
test('world play runs the world on its own at its rate; weather does not drive it', async (t) => {
test('world play and pause drive the weather replay', async (t) => {
const { clock, world, tick } = harness(t);
const radar = product('radar', [0, 10, 20]);
clock.register(radar);
world.seek(at(0));
world.seek(Date.parse(time(0)));
await flush();
world.play({ rate: 60 });
assert.equal(world.getState().stepping, false);
assert.equal(clock.getState().advancing, true);
tick(5_000);
assert.equal(world.now(), at(5), 'five minutes on at a minute a second');
tick(10_000);
world.play();
assert.equal(clock.getState().playing, true);
assert.equal(world.isPlaying(), true);
tick(2000);
await flush();
assert.equal(world.now(), at(10), 'held at the next frame');
assert.equal(radar.shown, time(10));
assert.equal(world.now(), Date.parse(time(10)));
world.pause();
assert.equal(clock.getState().advancing, false);
assert.equal(clock.getState().playing, false);
clock.play();
assert.equal(world.isPlaying(), true);
clock.pause();
assert.equal(world.isPlaying(), false);
clock.play();
world.goLive();
await flush();
assert.equal(clock.getState().playing, false);
assert.equal(clock.getState().mode, 'latest');
});
test('a moving world re-applies frames only when a product changes frame', async (t) => {
@@ -340,6 +416,15 @@ test('a moving world re-applies frames only when a product changes frame', async
assert.equal(radar.shown, time(10));
});
test('a world without frames to step plays on its own', async (t) => {
const { clock, world, tick } = harness(t);
world.seek(Date.parse(time(0)));
world.play();
assert.equal(clock.getState().playing, false);
tick(1000);
assert.equal(world.now(), Date.parse(time(0)) + 1000);
});
function worldAt(at) {
return createWorldClock({
now: () => at,
@@ -349,25 +434,74 @@ function worldAt(at) {
});
}
test('weather clocks sharing a world: the last one destroyed leaves it live', () => {
test('weather clocks sharing a world hand play over, and the last leaves it live', async () => {
const world = worldAt(Date.parse(time(20)));
const a = createWeatherClock({ world, now: () => Date.parse(time(20)) });
const b = createWeatherClock({ world, now: () => Date.parse(time(20)) });
a.register(product('radar', [0, 10, 20]));
b.register(product('radar', [0, 10, 20]));
world.seek(Date.parse(time(0)));
world.play();
const radarA = product('radar', [0, 10, 20]);
const radarB = product('radar', [0, 10, 20]);
a.register(radarA);
b.register(radarB);
await a.play();
assert.equal(world.isPlaying(), true);
world.pause();
assert.equal(a.getState().playing, false);
assert.equal(world.isPlaying(), false);
await a.play();
world.goLive();
assert.equal(a.getState().playing, false);
b.destroy();
assert.equal(world.follows('radar'), true);
assert.equal(world.isLive(), false);
assert.equal(world.isPlaying(), true);
world.seek(Date.parse(time(0)));
world.play();
assert.equal(a.getState().playing, true);
a.destroy();
assert.equal(world.follows('radar'), false);
assert.equal(world.isLive(), true);
assert.equal(world.isPlaying(), false);
});
test('each product’s frames span world clock coverage, with no marks, and support the timeline while shown', (t) => {
test('pausing from inside the first playing notice stops the world too', async (t) => {
const { clock, world } = harness(t);
clock.register(product('radar', [0, 10, 20]));
const off = clock.subscribe((state) => {
if (state.playing) {
off();
clock.pause();
}
});
await clock.play();
assert.equal(clock.getState().playing, false);
assert.equal(world.isPlaying(), false);
});
test('a step holds a world that was playing on its own', async (t) => {
const { clock, world } = harness(t);
world.seek(Date.parse(time(0)));
world.play();
clock.register(product('radar', [0, 10, 20]));
await clock.step(1);
assert.equal(world.isPlaying(), false);
assert.equal(world.now(), Date.parse(time(10)));
});
test('a target superseded from a listener resolves false', async (t) => {
const { clock } = harness(t);
const radar = product('radar', [0, 10, 20]);
clock.register(radar);
await flush();
let redirected = false;
clock.subscribe((state) => {
if (state.target === time(0) && !redirected) {
redirected = true;
void clock.setTarget(time(10));
}
});
assert.equal(await clock.setTarget(time(0)), false);
assert.equal(radar.shown, time(10));
});
test('each product’s frames are world clock coverage, and support the timeline while shown', (t) => {
const { clock, world } = harness(t);
assert.equal(world.coverage(), null);
assert.equal(world.getState().supported, false);
@@ -377,17 +511,11 @@ test('each product’s frames span world clock coverage, with no marks, and supp
assert.deepEqual(world.coverage(), {
start: Date.parse(time(0)),
end: Date.parse(time(10)),
marks: [],
markDetails: [],
marks: [0, 5, 10].map((m) => Date.parse(time(m))),
});
assert.equal(world.getState().supported, true);
unregister();
assert.deepEqual(world.coverage(), {
start: Date.parse(time(5)),
end: Date.parse(time(5)),
marks: [],
markDetails: [],
});
assert.deepEqual(world.coverage().marks, [Date.parse(time(5))]);
clock.destroy();
assert.equal(world.coverage(), null);
assert.equal(world.getState().supported, false);
@@ -400,12 +528,10 @@ test('a suspended product keeps its coverage, so the way back to live stays', (t
radar.suspended = true;
void clock.refresh();
assert.equal(world.getState().supported, true);
assert.deepEqual(world.coverage(), {
start: Date.parse(time(0)),
end: Date.parse(time(10)),
marks: [],
markDetails: [],
});
assert.deepEqual(
world.coverage().marks,
[0, 10].map((m) => Date.parse(time(m))),
);
});
test('new frames reach the world clock through refresh', (t) => {
+158 -90
View File
@@ -9,9 +9,7 @@ import {
GLOBAL_INFRARED_MAX_GAP_MS,
LIGHTNING_MAX_GAP_MS,
atLeastFrameSpacing,
createWeatherClock,
} from './clock.js';
import { worldClock } from '../../time/worldClock.js';
import { formatUtcDayMonth, t, msg } from '../../i18n/index.js';
import { formatScaleLabel } from '../../ui/unitLabels.js';
import { toLonLatH } from '../../geo/ellipsoid.js';
@@ -62,49 +60,12 @@ const utc = (value) =>
? `${formatUtcDayMonth(value)} ${value.slice(11, 16)} UTC`
: t('Unavailable');
/**
* Move `world`, the world clock, as its timeline does: `play` toggles play
* (from the start of the covered time when live) and `latest` goes live.
* `step` (-1 or 1) goes to the previous or next of `frames`, the weather
* frames; the timeline does not mark them, so this is the row's own way to
* step through them.
*/
function moveWorldTime(world, frames, { play, latest, step }) {
if (!world) return;
if (play === true) {
const state = world.getState();
if (state.playing) world.pause();
else {
const covered = world.coverage();
if (state.live && covered) world.seek(covered.start);
world.play({ continuous: true });
}
}
if (latest === true) world.goLive();
if (step === -1 || step === 1) {
const at = world.getState().timeMs;
const times = frames
.map((time) => Date.parse(time))
.filter(Number.isFinite)
.sort((a, b) => a - b);
const to =
step < 0
? times.findLast((frame) => frame < at)
: times.find((frame) => frame > at);
if (to === undefined) return;
world.pause();
world.seek(to);
}
}
/** A per-application observation layer, using the existing layer lifecycle and
* row controls. Its time is the world clock's, so a link made away from live
* opens its imagery at that time; one made live opens the latest. Its frames
* follow `clock`, a weather clock several layers share; without one the layer
* keeps its own on the page's world clock, for its lifetime. */
* opens its imagery at that time; one made live opens the latest. */
export function createWeatherLayer({
feed,
clock: sharedClock,
clock,
id = 'weather-radar',
createRendering = createWeatherRendering,
documentRef = globalThis.document,
@@ -113,10 +74,6 @@ export function createWeatherLayer({
} = {}) {
if (typeof feed?.getSnapshot !== 'function')
throw new TypeError('Weather requires a snapshot source');
const ownClock = sharedClock
? null
: createWeatherClock({ world: worldClock });
const clock = sharedClock ?? ownClock;
// A feed may also supply decoded frames; see weatherFrameSource.
const radar = id === 'weather-radar';
const lightning = id === 'weather-lightning';
@@ -130,8 +87,11 @@ export function createWeatherLayer({
request = null,
listener = null;
let enabled = false,
loading = false;
loading = false,
playing = false,
followLatest = true;
let generation = 0,
timer = null,
error = null,
removeCamera = null;
let motion = null;
@@ -171,11 +131,12 @@ export function createWeatherLayer({
return spaced;
};
const maxGap = () => spacedTimes().gap;
const isLatest = () => clock.getState().mode === 'latest';
const isLatest = () =>
clock ? clock.getState().mode === 'latest' : followLatest;
const getHost = () => imageryHost?.() ?? globeImageryHost(viewer);
const notify = () => listener?.();
const shownTime = () => (noFrame ? null : rendering?.getDiagnostics().time);
const unsubscribeClock = clock.subscribe(() => {
const unsubscribeClock = clock?.subscribe(() => {
if (!clock.getState().advancing || suspended())
rendering?.cancelPrefetch?.();
notify();
@@ -183,18 +144,26 @@ export function createWeatherLayer({
// Ages and delays are measured from the time the layer shows: the world
// clock's time at a past time, the wall clock while live.
const worldNow = () => {
const shared = clock.getState();
return shared.mode === 'history' && shared.target
const shared = clock?.getState();
return shared?.mode === 'history' && shared.target
? Date.parse(shared.target)
: Date.now();
};
const observationDelayed = () =>
manifest?.latest &&
worldNow() - Date.parse(manifest.latest) > spacedTimes().delay;
const stop = () => {
if (clock) return;
playing = false;
rendering?.cancelPrefetch?.();
clearTimeout(timer);
timer = null;
};
const suspended = () => hostHidden || documentRef?.hidden || motion?.matches;
const onVisibility = () => {
if (suspended()) rendering?.cancelPrefetch?.();
void clock.refresh();
if (clock) void clock.refresh();
else if (suspended()) stop();
notify();
};
@@ -209,15 +178,46 @@ export function createWeatherLayer({
if (!changed || !rendering) return;
++generation;
rendering.rehome?.();
clearTimeout(timer);
timer = null;
loading = Boolean(request && !request.signal.aborted);
if (enabled && resume) {
void clock.refresh();
if (!hostHidden && manifest && isLatest()) void show(manifest.latest);
if (clock && enabled) {
if (resume) {
void clock.refresh();
if (!hostHidden && manifest && isLatest()) void show(manifest.latest);
}
notify();
return;
}
if (resume && enabled && !hostHidden && manifest) {
const time =
followLatest || !manifest.times.includes(shownTime())
? manifest.latest
: shownTime();
if (
time !== shownTime() ||
(satellite && rendering.getDiagnostics().infrared !== infrared)
)
void show(time);
else schedule();
}
notify();
}
const onMapStackChanged = () => checkHost();
function schedule() {
if (clock) return;
clearTimeout(timer);
timer = null;
if (!enabled || !playing || suspended()) return;
timer = setTimeout(() => {
timer = null;
const times = manifest?.times || [];
const next = (times.indexOf(shownTime()) + 1) % times.length;
if (times[next]) void show(times[next]);
else stop();
}, 2000);
}
async function applyClockTime(time, { signal }) {
if (!enabled || signal.aborted) return false;
if (time !== null) return show(time, signal);
@@ -231,7 +231,7 @@ export function createWeatherLayer({
return true;
}
function registerClock() {
if (unregisterClock || !rendering || !enabled) return;
if (!clock || unregisterClock || !rendering || !enabled) return;
unregisterClock = clock.register({
id,
get maxGapMs() {
@@ -244,11 +244,15 @@ export function createWeatherLayer({
});
}
async function warmNext(time) {
if (!enabled || suspended() || !clock.getState().advancing) return;
// The world plays on past the newest frame, never round to the first.
if (
!enabled ||
suspended() ||
!(clock ? clock.getState().advancing : playing)
)
return;
const times = manifest?.times ?? [];
const next = times[times.indexOf(time) + 1];
if (!next) return;
const next = times[(times.indexOf(time) + 1) % times.length];
if (!next || next === time) return;
try {
await rendering.prefetch?.(manifest, next, { infrared });
} catch {
@@ -283,10 +287,13 @@ export function createWeatherLayer({
error = ok
? null
: msg('Frame unavailable; previous observation retained');
if (!ok) stop();
return ok;
} catch {
if (owner === generation && !controller.signal.aborted)
if (owner === generation && !controller.signal.aborted) {
error = msg('Weather imagery unavailable');
stop();
}
return false;
} finally {
signal?.removeEventListener('abort', abort);
@@ -294,7 +301,8 @@ export function createWeatherLayer({
if (owner === generation) {
loading = Boolean(request && !request.signal.aborted);
notify();
if (isLatest()) void clock.refresh();
if (clock && isLatest()) void clock.refresh();
schedule();
}
}
}
@@ -363,20 +371,26 @@ export function createWeatherLayer({
noFrame = false;
request?.abort();
request = null;
rendering?.cancelPrefetch?.();
stop();
rendering?.clear();
manifest = null;
loading = false;
error = null;
followLatest = true;
},
async update(_viewer, { signal } = {}) {
if (!enabled) return false;
checkHost(false);
clearTimeout(timer);
timer = null;
request?.abort();
const controller = new AbortController();
if (signal?.aborted) controller.abort(signal.reason);
request = controller;
const abort = () => controller.abort(signal.reason);
const abort = () => {
controller.abort(signal.reason);
stop();
};
signal?.addEventListener('abort', abort, { once: true });
loading = true;
notify();
@@ -392,15 +406,36 @@ export function createWeatherLayer({
error = msg(
'Weather source unavailable; previous observation retained',
);
stop();
return true;
}
manifest = snapshot;
error = null;
// The shown frame may stay; its credit follows the refreshed manifest.
rendering?.updateSnapshot?.(snapshot);
await clock.refresh();
if (isLatest() && request === controller && !controller.signal.aborted)
await show(snapshot.latest, controller.signal);
if (clock) {
await clock.refresh();
if (
isLatest() &&
request === controller &&
!controller.signal.aborted
)
await show(snapshot.latest, controller.signal);
return (
enabled &&
!signal?.aborted &&
(!controller.signal.aborted || request !== controller)
);
}
const time =
followLatest || !snapshot.times.includes(shownTime())
? snapshot.latest
: shownTime();
if (
shownTime() !== time ||
(satellite && rendering.getDiagnostics().infrared !== infrared)
)
await show(time, controller.signal);
return (
enabled &&
!signal?.aborted &&
@@ -410,6 +445,7 @@ export function createWeatherLayer({
if (controller.signal.aborted || request !== controller)
return enabled && !signal?.aborted && request !== controller;
error = cause?.message || msg('Weather unavailable');
stop();
return true;
} finally {
signal?.removeEventListener('abort', abort);
@@ -417,6 +453,7 @@ export function createWeatherLayer({
request = null;
loading = Boolean(rendering?.getDiagnostics().loading);
notify();
schedule();
}
}
},
@@ -451,16 +488,19 @@ export function createWeatherLayer({
noFrame = false;
request?.abort();
request = null;
rendering?.cancelPrefetch?.();
stop();
manifest = null;
error = null;
loading = false;
followLatest = true;
rendering?.clear();
void clock.refresh();
if (clock) void clock.refresh();
if (enabled) void layer.update(viewer);
}
if (infraredChanged && enabled && manifest) {
if (!isLatest()) void clock.refresh();
clearTimeout(timer);
timer = null;
if (clock && !isLatest()) void clock.refresh();
else void show(shownTime() || manifest.latest);
}
if (
@@ -488,16 +528,38 @@ export function createWeatherLayer({
);
});
}
// Time is the world's: these move the world clock as its timeline
// does, and every layer that follows it moves along. A step goes
// through every shown observation's frames, and this row's own even
// while it is suspended.
if (enabled)
moveWorldTime(
clock.world,
[...clock.getTimeline(), ...(manifest?.times ?? [])],
params,
if (clock && enabled) {
if (params.play === true) void clock.togglePlay();
if (params.latest === true) void clock.latest();
if ([-1, 1].includes(params.step)) void clock.step(params.step);
}
if (
!clock &&
params.play === true &&
enabled &&
manifest?.times?.length > 1 &&
!suspended()
) {
playing = !playing;
followLatest = false;
if (playing) schedule();
else stop();
}
if (!clock && params.latest === true && manifest) {
stop();
followLatest = true;
void show(manifest.latest);
}
if (!clock && [-1, 1].includes(params.step) && manifest && !loading) {
stop();
followLatest = false;
const at = manifest.times.indexOf(shownTime());
const next = Math.max(
0,
Math.min(manifest.times.length - 1, at + params.step),
);
void show(manifest.times[next]);
}
notify();
},
getParams() {
@@ -508,13 +570,13 @@ export function createWeatherLayer({
: { product, opacity };
},
getRowControls() {
const shared = clock.getState();
const shared = clock?.getState();
const followLatest = isLatest();
// Source-described text is data: shown as is, never translated.
const display = weatherDisplay(manifest);
const missing =
noFrame &&
shared.mode === 'history' &&
shared?.mode === 'history' &&
shared.products.find((entry) => entry.id === id)?.selected === null
? maxGap() / 60_000 < 60
? t('No frame within {gap} min of {time}', {
@@ -635,7 +697,9 @@ export function createWeatherLayer({
const stops =
display.legend ?? (radar ? STOPS : lightning ? LIGHTNING_STOPS : []);
const infoMotion = motion?.matches
? t('Reduced motion · history playback unavailable')
? clock
? t('Reduced motion · history playback unavailable')
: t('Reduced motion · manual history available')
: '';
const controls = {
readout: true,
@@ -825,23 +889,27 @@ export function createWeatherLayer({
};
},
getDiagnostics() {
const shared = clock.getState();
const shared = clock?.getState();
return {
...rendering?.getDiagnostics(),
playing: shared.advancing,
playing: shared ? shared.playing : playing && !hostHidden,
followLatest: isLatest(),
clock: {
mode: shared.mode,
target: shared.target,
playing: shared.advancing,
},
...(shared
? {
clock: {
mode: shared.mode,
target: shared.target,
playing: shared.playing,
},
}
: {}),
historyFrames: manifest?.times?.length || 0,
timerActive: timer !== null,
};
},
destroy() {
layer.disable();
unsubscribeClock();
ownClock?.destroy();
unsubscribeClock?.();
removeCamera?.();
removeCamera = null;
motion?.removeEventListener?.('change', onVisibility);
+102 -175
View File
@@ -1,9 +1,8 @@
import test, { afterEach } from 'node:test';
import test from 'node:test';
import assert from 'node:assert/strict';
import { createWeatherRendering, READY_WAKE_MS } from './rendering.js';
import { createWeatherLayer } from './index.js';
import { createWeatherClock } from './clock.js';
import { worldClock } from '../../time/worldClock.js';
import * as Cesium from 'cesium';
import { Color, ImageryLayerCollection, GeographicTilingScheme } from 'cesium';
import { NO_IMAGERY_HOST } from './imageryHost.js';
@@ -42,16 +41,6 @@ const deferred = () => {
const flush = async () => {
for (let i = 0; i < 30; i++) await Promise.resolve();
};
// Time moves on the world clock the weather clock follows, as the timeline
// moves it.
const seekTo = (clock, time) => {
clock.world.seek(Date.parse(time));
return flush();
};
const goLive = (clock) => {
clock.world.goLive();
return flush();
};
function event() {
const listeners = new Set();
return {
@@ -568,14 +557,6 @@ test('failed and timed-out stages retain the previous observation; a healthy rep
h.rendering.clear();
});
// A layer built without a clock keeps its own on the page's world clock:
// each test leaves that clock live, with no layer of its own on it.
const harnessed = new Set();
afterEach(() => {
for (const layer of harnessed) layer.destroy();
harnessed.clear();
worldClock.goLive();
});
function layerHarness({
clock,
reducedMotion = false,
@@ -657,7 +638,6 @@ function layerHarness({
});
layer.init(viewer);
layer.enable();
harnessed.add(layer);
return {
layer,
rendering,
@@ -671,96 +651,72 @@ function layerHarness({
};
}
test('without a clock the layer keeps one of its own on the world clock and lets it go on destroy', async () => {
test('history has one owned timer, stops while hidden, and releases all work on disable/destroy', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const h = layerHarness();
const update = h.layer.update();
await flush();
h.stages[0].finish();
await update;
assert.equal(worldClock.follows('weather-radar'), true);
// The frames span the timeline's time; they are not marks on it.
assert.deepEqual(worldClock.coverage(), {
start: Date.parse(times[0]),
end: Date.parse(times.at(-1)),
marks: [],
markDetails: [],
});
h.layer.setParams({ play: true });
assert.equal(worldClock.isPlaying(), true);
assert.equal(worldClock.getState().stepping, false);
assert.equal(h.layer.getDiagnostics().playing, true);
assert.equal(h.layer.getDiagnostics().timerActive, true);
t.mock.timers.tick(2000);
assert.equal(h.stages.length, 2);
assert.equal(
h.layer.getDiagnostics().timerActive,
false,
'next timer waits for stage settlement',
);
h.stages[1].finish();
await flush();
assert.equal(h.layer.getDiagnostics().timerActive, true);
h.documentRef.hidden = true;
h.documentRef.emit('visibilitychange');
await flush();
assert.equal(worldClock.isPlaying(), true, 'hiding suspends the layer only');
assert.equal(h.layer.getDiagnostics().playing, false);
assert.equal(h.layer.getDiagnostics().timerActive, false);
t.mock.timers.tick(20_000);
assert.equal(h.stages.length, 2);
h.documentRef.hidden = false;
h.documentRef.emit('visibilitychange');
h.layer.setParams({ play: true });
assert.equal(worldClock.isPlaying(), false);
h.layer.disable();
assert.equal(h.layer.getDiagnostics().timerActive, false);
assert.equal(h.layer.getDiagnostics().historyFrames, 0);
t.mock.timers.tick(20_000);
assert.equal(h.stages.length, 2);
h.layer.destroy();
assert.equal(worldClock.follows('weather-radar'), false);
assert.equal(h.documentRef.size, 0);
assert.equal(h.motion.size, 0);
assert.equal(h.moveEnd.size, 0);
assert.ok(h.clears() >= 1);
});
test('reduced motion offers no play; steps still move the world clock from frame to frame', async () => {
test('reduced motion blocks autoplay but permits manual history and stops newly suspended playback', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const h = layerHarness({ reducedMotion: true });
const update = h.layer.update();
await flush();
h.stages[0].finish();
await update;
h.layer.setParams({ play: true });
assert.equal(h.layer.getDiagnostics().timerActive, false);
assert.equal(
h.layer.getRowControls().chips.some((chip) => chip.id === 'play'),
false,
);
// A step back from live goes to the newest frame, and the next one back
// to the frame before it.
h.layer.setParams({ step: -1 });
assert.equal(h.stages[1].time, times[1]);
h.stages[1].finish();
await flush();
assert.equal(worldClock.now(), Date.parse(times[2]));
h.layer.setParams({ step: -1 });
await flush();
assert.equal(worldClock.now(), Date.parse(times[1]));
assert.equal(h.stages.at(-1).time, times[1]);
});
test('a row steps forward and plays from a past time through the world clock', async () => {
const h = layerHarness();
const update = h.layer.update();
await flush();
h.stages[0].finish();
await update;
worldClock.seek(Date.parse(times[0]));
await flush();
h.layer.setParams({ step: 1 });
assert.equal(worldClock.now(), Date.parse(times[1]));
assert.equal(worldClock.isPlaying(), false);
await flush();
assert.equal(h.stages.at(-1).time, times[1]);
h.layer.setParams({ step: 1 });
assert.equal(worldClock.now(), Date.parse(times[2]));
h.layer.setParams({ step: 1 });
assert.equal(
worldClock.now(),
Date.parse(times[2]),
'no frame after the newest',
);
worldClock.seek(Date.parse(times[1]));
await flush();
h.motion.matches = false;
h.motion.emit('change');
h.layer.setParams({ play: true });
assert.equal(worldClock.isPlaying(), true);
assert.equal(worldClock.getState().stepping, false);
assert.ok(
worldClock.now() - Date.parse(times[1]) < 1_000,
'away from live, play goes on from the time shown',
);
h.layer.setParams({ step: 1 });
assert.equal(worldClock.isPlaying(), false, 'a step holds play');
assert.equal(worldClock.now(), Date.parse(times[2]));
assert.equal(h.layer.getDiagnostics().playing, true);
h.motion.matches = true;
h.motion.emit('change');
assert.equal(h.layer.getDiagnostics().playing, false);
assert.equal(h.layer.getDiagnostics().timerActive, false);
h.layer.destroy();
});
test('disable invalidates an abort-insensitive source result and an already staged frame', async (t) => {
@@ -789,6 +745,7 @@ test('disable invalidates an abort-insensitive source result and an already stag
await next;
await flush();
assert.equal(h.layer.getStats().count, 0);
assert.equal(h.layer.getDiagnostics().timerActive, false);
assert.equal(h.layer.getStats().loading, false);
h.layer.destroy();
});
@@ -847,6 +804,7 @@ test('update cancellation reaches imagery after source acquisition has completed
assert.equal(h.stages[0].signal.aborted, true);
assert.equal(h.layer.getStats().count, 0);
assert.equal(h.layer.getStats().loading, false);
assert.equal(h.layer.getDiagnostics().timerActive, false);
h.layer.destroy();
});
@@ -954,22 +912,21 @@ test('coverage navigation requires the shared shell handoff and detaches cleanly
h.layer.destroy();
});
test('manifest refresh during a history stage restages the same time and does not strand loading controls', async () => {
test('manifest refresh during a manual history stage does not strand loading controls', async () => {
const h = layerHarness();
const first = h.layer.update();
await flush();
h.stages[0].finish();
await first;
worldClock.seek(Date.parse(times[1]));
await flush();
h.layer.setParams({ step: -1 });
assert.equal(h.layer.getStats().loading, true);
const refreshed = h.layer.update();
await flush();
assert.equal(h.stages.length, 3);
assert.equal(h.stages[1].signal.aborted, true);
assert.equal(h.stages[2].time, times[1], 'the refresh keeps the time');
h.stages[2].finish();
await refreshed;
await h.layer.update();
assert.equal(
h.stages.length,
2,
'metadata refresh preserves the staged manual selection',
);
h.stages[1].finish();
await flush();
assert.equal(h.layer.getStats().loading, false);
assert.equal(h.layer.getStats().observedAt, times[1]);
@@ -999,8 +956,7 @@ test('historical observations do not relabel a fresh lightning feed as stale', a
await flush();
h.stages[0].finish();
await first;
worldClock.seek(Date.parse(old));
await flush();
h.layer.setParams({ step: -1 });
h.stages[1].finish();
await flush();
assert.equal(h.layer.getStats().stale, false);
@@ -1357,7 +1313,8 @@ test('404 fails a frame without retry', async () => {
h.rendering.clear();
});
test('no host holds the shown history frame, refreshes metadata, and restores the retained time', async () => {
test('no host pauses history, refreshes metadata, and restores retained time and playback', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
let refreshes = 0;
const h = layerHarness({
feed: {
@@ -1373,23 +1330,28 @@ test('no host holds the shown history frame, refreshes metadata, and restores th
await flush();
h.stages[0].finish();
await update;
worldClock.seek(Date.parse(times[0]));
await flush();
h.layer.setParams({ play: true });
t.mock.timers.tick(2000);
assert.equal(h.stages.length, 2);
h.stages[1].finish();
await flush();
host = { collection: null, kind: 'none' };
h.eventTarget.emit('gev:map-stack-changed');
await flush();
assert.equal(h.layer.getDiagnostics().playing, false);
assert.equal(h.layer.getDiagnostics().timerActive, false);
assert.equal(h.layer.getRowControls().summary.status, NO_IMAGERY_HOST);
assert.equal(h.layer.getRowControls().info, NO_IMAGERY_HOST);
await h.layer.update();
assert.equal(refreshes, 2);
assert.equal(h.stages.length, 2, 'nothing stages without a host');
t.mock.timers.tick(10_000);
assert.equal(h.stages.length, 2);
assert.equal(h.layer.getDiagnostics().time, times[2]);
host = { collection: {}, kind: 'globe' };
h.eventTarget.emit('gev:map-stack-changed');
await flush();
assert.equal(h.stages.at(-1).time, times[0], 'the retained time restages');
assert.equal(h.layer.getDiagnostics().playing, true);
assert.equal(h.layer.getDiagnostics().timerActive, true);
t.mock.timers.tick(2000);
assert.equal(h.stages.length, 3);
assert.equal(h.stages[2].time, times[0]);
h.layer.destroy();
assert.equal(h.eventTarget.size, 0);
});
@@ -1503,21 +1465,25 @@ for (const [id, product] of [
const [shell] = h.shells();
assert.equal(shell.show, true);
worldClock.seek(Date.parse(times[0]));
layer.setParams({ play: true });
t.mock.timers.tick(2000);
await flush();
assert.equal(
layer.getDiagnostics().time,
times[0],
'history moves at street level',
'history advances at street level',
);
camera.positionCartographic.height = 59_999;
camera.moveEnd.emit();
assert.equal(shell.show, true, 'no height gate');
assert.equal(layer.getDiagnostics().playing, true);
assert.equal(layer.getDiagnostics().timerActive, true);
host = { collection: null, kind: 'none' };
events.emit('gev:map-stack-changed');
assert.equal(shell.show, false);
assert.equal(layer.getRowControls().summary.status, NO_IMAGERY_HOST);
assert.equal(layer.getDiagnostics().timerActive, false);
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
events.emit('gev:map-stack-changed');
assert.equal(shell.destroyed, true);
@@ -1709,12 +1675,10 @@ test('satellite mode chips restage history without changing time or latest-follo
await flush();
h.stages[0].finish();
await update;
worldClock.seek(Date.parse(times[1]));
await flush();
h.layer.setParams({ step: -1 });
h.stages[1].finish();
await flush();
h.layer.setParams({ infrared: 'full' });
await flush();
assert.equal(h.stages[2].time, times[1]);
assert.equal(h.stages[2].infrared, 0);
assert.equal(h.layer.getParams().infrared, 0);
@@ -1838,7 +1802,7 @@ test('a delayed installation failure retains the replacement and does not throw
h.rendering.clear();
});
test('a row steps the world clock through every registered observation; missing frames hide and latest goes live', async (t) => {
test('one row steps every registered observation; missing frames hide and latest restores each product', async (t) => {
const clock = createWeatherClock();
const radar = layerHarness({ clock });
const satellite = layerHarness({
@@ -1871,14 +1835,6 @@ test('a row steps the world clock through every registered observation; missing
.chips.filter(({ id }) =>
['previous', 'play', 'next', 'latest'].includes(id),
);
// A step back from live goes to the newest frame, and the next one back
// to the frame before it.
radar.layer.setParams({ step: -1 });
await flush();
assert.equal(clock.getState().target, times[2]);
assert.equal(clock.world.isPlaying(), false);
for (const h of [radar, satellite]) h.stages.at(-1)?.finish();
await flush();
radar.layer.setParams({ step: -1 });
await flush();
assert.equal(clock.getState().target, times[1]);
@@ -1930,33 +1886,6 @@ test('a row steps the world clock through every registered observation; missing
assert.equal(clock.getState().products.length, 1);
});
test('a row’s play and latest move the world clock as its timeline does', async (t) => {
const clock = createWeatherClock();
const { world } = clock;
const h = layerHarness({ clock });
t.after(() => {
h.layer.destroy();
clock.destroy();
});
const update = h.layer.update();
await flush();
h.stages.at(-1).finish();
await update;
h.layer.setParams({ play: true });
assert.equal(world.isPlaying(), true);
assert.equal(world.getState().stepping, false, 'the world plays on its own');
assert.ok(
world.now() - Date.parse(times[0]) < 1_000,
'from the start when live',
);
h.layer.setParams({ play: true });
assert.equal(world.isPlaying(), false);
h.layer.setParams({ latest: true });
assert.equal(world.isLive(), true);
await flush();
assert.equal(clock.getState().mode, 'latest');
});
test('history manifest expiry hides imagery without jumping to latest; host resume keeps the target', async (t) => {
const clock = createWeatherClock();
let value = snapshot;
@@ -1969,7 +1898,7 @@ test('history manifest expiry hides imagery without jumping to latest; host resu
await flush();
h.stages.at(-1).finish();
await update;
const history = seekTo(clock, times[0]);
const history = clock.setTarget(times[0]);
await flush();
h.stages.at(-1).finish();
await history;
@@ -2038,7 +1967,7 @@ test('satellite global selection uses the three-hour gap and preserves the share
await flush();
h.stages.at(-1).finish();
await update;
await seekTo(clock, times[0]);
await clock.setTarget(times[0]);
assert.equal(
h.layer.getDiagnostics().hidden,
true,
@@ -2097,8 +2026,7 @@ test('satellite clouds from an hourly feed draw all through each hour and read l
);
// Forty-five minutes past a frame, between it and the next, it still shows.
const between = seekTo(
clock,
const between = clock.setTarget(
new Date(Date.parse(hourly[0]) + 45 * 60_000).toISOString(),
);
await flush();
@@ -2109,7 +2037,7 @@ test('satellite clouds from an hourly feed draw all through each hour and read l
// Live again (a past time judges delay from the timeline's time), past
// one and a half hours it reads late.
const live = goLive(clock);
const live = clock.latest();
await flush();
h.stages.at(-1).finish();
await live;
@@ -2131,11 +2059,11 @@ test('switching to history cancels a still-loading latest refresh and a later ta
const update = h.layer.update();
await flush();
const latest = h.stages.at(-1);
const oldHistory = seekTo(clock, times[0]);
const oldHistory = clock.setTarget(times[0]);
await flush();
assert.equal(latest.signal.aborted, true);
const oldStage = h.stages.at(-1);
const current = seekTo(clock, times[1]);
const current = clock.setTarget(times[1]);
await flush();
assert.equal(oldStage.signal.aborted, true);
h.stages.at(-1).finish();
@@ -2445,9 +2373,8 @@ test('failed prefetch leaves the current frame and errors unchanged and releases
assert.deepEqual(h.rendering.getDiagnostics(), before);
});
test('as the world plays, the layer warms the next advertised observation after each frame that shows', async (t) => {
test('layer warms the next advertised observation only after a successful playing frame, wrapping at the end', async (t) => {
const clock = createWeatherClock();
const { world } = clock;
const h = layerHarness({ clock });
const warmed = [];
let cancels = 0;
@@ -2465,45 +2392,45 @@ test('as the world plays, the layer warms the next advertised observation after
await flush();
h.stages.at(-1).finish();
await updated;
await seekTo(clock, times[0]);
h.stages.at(-1).finish();
assert.equal(warmed.length, 0);
const play = clock.play();
await flush();
assert.equal(warmed.length, 0, 'paused, nothing is warmed');
world.play({ rate: 1e-9, continuous: true });
assert.equal(clock.getState().advancing, true);
await seekTo(clock, times[1]);
assert.equal(warmed.length, 0, 'still staging');
h.stages.at(-1).finish();
await flush();
await play;
assert.deepEqual(
warmed.map(({ time }) => time),
[times[2]],
[times[0]],
);
assert.deepEqual(warmed[0].options, { infrared: 100 });
await seekTo(clock, times[0]);
const next = clock.setTarget(times[0]);
await flush();
h.stages.at(-1).finish();
await next;
assert.deepEqual(
warmed.map(({ time }) => time),
[times[0], times[1]],
);
const failed = clock.setTarget(times[1]);
await flush();
h.stages.at(-1).finish(false);
await flush();
assert.equal(warmed.length, 1, 'a failed frame warms nothing');
await seekTo(clock, times[2]);
h.stages.at(-1).finish();
await flush();
assert.equal(warmed.length, 1, 'the world plays on past the newest frame');
await failed;
assert.equal(warmed.length, 2);
const priorCancels = cancels;
world.pause();
await flush();
clock.pause();
assert.ok(cancels > priorCancels);
await seekTo(clock, times[1]);
h.stages.at(-1).finish();
const paused = clock.setTarget(times[2]);
await flush();
assert.equal(warmed.length, 1);
world.play({ rate: 1e-9, continuous: true });
h.stages.at(-1).finish();
await paused;
assert.equal(warmed.length, 2);
await clock.play();
h.documentRef.hidden = true;
h.documentRef.emit('visibilitychange');
await flush();
h.stages.at(-1)?.finish();
h.stages.at(-1).finish();
await flush();
assert.equal(warmed.length, 1, 'hidden products do not prefetch');
world.goLive();
assert.equal(warmed.length, 2, 'hidden products do not prefetch');
});
for (const product of ['radar', 'clouds-regional', 'lightning']) {
@@ -2840,7 +2767,7 @@ test('at a past time a frame is aged and its source judged delayed from the time
// Years later, the world clock is moved back to the newest frame.
Date.now.mock.mockImplementation(() => Date.parse('2032-01-01T00:00:00Z'));
void seekTo(clock, times[2]);
void clock.setTarget(times[2]);
await flush();
h.stages.at(-1)?.finish();
await flush();
@@ -2851,7 +2778,7 @@ test('at a past time a frame is aged and its source judged delayed from the time
assert.equal(h.layer.getStats().stale, false);
// Ten minutes after the newest frame, the frame is ten minutes old.
void seekTo(clock, '2026-09-15T20:20:00.000Z');
void clock.setTarget('2026-09-15T20:20:00.000Z');
await flush();
h.stages.at(-1)?.finish();
await flush();
+4 -9
View File
@@ -390,24 +390,20 @@ test('sample stays fixed across model, field and unit changes; dismissal and dis
test('observed history labels wind as a forecast without changing its data or parameters', async () => {
const { createWeatherClock } = await import('../weather/clock.js');
const clock = createWeatherClock();
const { world } = clock;
const layer = createWindLayer({ feed: { getSnapshot: async () => snapshot('gfs') }, clock });
let changes = 0;
layer.setRowControlsListener(() => changes++);
const params = layer.getParams();
world.seek(Date.parse('2026-09-14T12:00:00.000Z'));
await Promise.resolve();
await clock.setTarget('2026-09-14T12:00:00.000Z');
assert.equal(layer.getRowControls().summary.status, null, 'history does not mask source status');
assert.ok(changes > 0);
assert.match(layer.getRowControls().info, /Forecast · does not follow history/);
assert.deepEqual(layer.getParams(), params);
world.goLive();
await Promise.resolve();
await clock.latest();
assert.equal(layer.getRowControls().summary.status, null);
layer.destroy();
const before = changes;
world.seek(Date.parse('2026-09-14T12:00:00.000Z'));
await Promise.resolve();
await clock.setTarget('2026-09-14T12:00:00.000Z');
assert.equal(changes, before);
clock.destroy();
});
@@ -466,8 +462,7 @@ test('wind whose source follows the timeline drops the note that it does not fol
const clock = createWeatherClock({ world });
const layer = createWindLayer({ feed: { getSnapshot: async () => snapshot('gfs') }, clock });
world.follow('wind');
world.seek(Date.parse('2026-09-14T12:00:00.000Z'));
await Promise.resolve();
await clock.setTarget('2026-09-14T12:00:00.000Z');
assert.equal(clock.getState().mode, 'history');
assert.doesNotMatch(layer.getRowControls().info, /does not follow history/);
world.follow('wind', false);