feat(earthquakes): select quakes by click and show their details

Clicking a quake's disc selects it and shows a card with its magnitude and
USGS class, a class meter with the depth band, place, UTC time and source.
With a USGS event id the card opens the event page. Clicking a magnitude
label, the part a far view can hit, also flies the camera to the quake. The
selection joins the shared context selection, so "what's selected" answers
with it.

The selected disc is painted with a gradient that fades to its outer circle,
and wavy contour lines run out from the marker for three cycles while it is
on screen, then rest as still contours, so a parked camera returns to idle.
A feed refresh updates the selection in place without restarting the lines
or taking back the shared selection.

The package takes input, picking, context, focus, the opener, the painter
and the translator by injection; without them it draws as before.
This commit is contained in:
manjunath22466 committed 2026-11-16 17:55:29 +05:30
1 parent da81cf743b
commit a8ac8eeb9b
25 files changed
+2292 -34

No files matched your search

+367 -30
View File
@@ -11,6 +11,11 @@ import {
selectEarthquakeOverlayCohort,
mapAnalystRecord,
earthquakeCoverage,
earthquakeMarkLabel,
earthquakeMagnitudeTitle,
earthquakeZoomLabel,
earthquakeDiscRadiusM,
describeEarthquake,
} from './model.js';
export * from './model.js';
export { createUsgsEarthquakeSource } from './source.js';
@@ -25,6 +30,18 @@ const msg = (text) => text;
* as `Hit.set`.
*/
export const EARTHQUAKE_DISC_SET_ID = 'earthquakes';
export const EARTHQUAKES_LAYER_ID = 'earthquakes';
/** The overlay source the clicked quake's detail card is shown in. */
export const EARTHQUAKE_CARD_SOURCE_ID = 'earthquake-card';
/** A disc's item id is this prefix and the event's stable id. */
const PICK_PREFIX = 'earthquake:';
/** The selected quake's flat fill, faint under the painted gradient. */
const SELECTED_DISC_ALPHA = 0.04;
const CARD_HOST_OPTIONS = Object.freeze({
cohortLimit: 1,
collisionCapacity: 1,
moving: false,
});
let instances = 0;
/**
@@ -33,8 +50,42 @@ let instances = 0;
* The discs are one renderer draw set (`drawOf(viewer)`), made at `init`.
* Given a Cesium viewer with no renderer bound, the
* caller loads the package's `./render/cesium/unbound` export first.
*
* Clicking a disc shows that quake's detail card and selects it in the
* shared context. The application gives the click and selection services;
* without `input` and `picking` the discs are drawn but take no clicks.
* @param {object} options
* @param {object} options.source Snapshot source.
* @param {object} options.overlayHost World-overlay host (`hitTest` lets
* the card be clicked).
* @param {(viewer: object) => {onClick: Function}} [options.input] The
* viewer's click dispatcher.
* @param {{resolvePickId: Function, isOwnedByOtherLayer: Function,
* registerPickOwner: Function, unregisterPickOwner: Function}} [options.picking]
* @param {{registerEntityContext: Function, selectEntityContext: Function,
* clearSelectedEntityContextForLayer: Function,
* getContextStore: Function}} [options.context] Shared selection store.
* @param {{isPointerFree: () => boolean}} [options.pointer]
* @param {(url: string) => void} [options.openExternal]
* @param {{requestWorldFocus: (detail: object) => boolean}} [options.focus]
* The camera transfer a clicked magnitude label asks for.
* @param {{show: (target: {id: string, lon: number, lat: number,
* radiusM: number, color: string}) => void, hide: () => void}} [options.ripples]
* The selected quake's animated contour rings.
* @param {object} [options.text] Card formatters (see describeEarthquake).
*/
export function createEarthquakesLayer({ source, overlayHost } = {}) {
export function createEarthquakesLayer({
source,
overlayHost,
input = null,
picking = null,
context = null,
pointer = null,
openExternal = null,
focus = null,
ripples = null,
text = undefined,
} = {}) {
if (typeof source?.getSnapshot !== 'function')
throw new TypeError('Earthquakes require a snapshot source');
if (!overlayHost) throw new TypeError('Earthquakes require an overlay host');
@@ -60,6 +111,270 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) {
_marksKey = key;
worldClock.coverageChanged();
};
// The drawn events by stable id, for clicks; the selected one's id, card
// and the context record it was published as.
let _eventById = new Map();
let _selectedId = null;
let _selectedCardId = null;
let _selectedLink = null;
let _contextId = null;
let _clickHandler = null;
const canSelect = () => Boolean(input && picking);
// The disc whose flat fill is faded while the painter draws its gradient.
let _fadedDiscId = null;
/**
* A quake's disc: filled on the ground, with static axes (re-tessellating
* clamped ground geometry every frame is what once cost 30 fps). No
* outline: clamped to the ground, Cesium never drew one. A selected
* quake's disc is all but clear: the ripples painter fills it with a
* gradient instead, and the faint fill keeps it pickable.
*/
function discItem(event, faded = false) {
const radius = earthquakeDiscRadiusM(event.mag);
const [r, g, b] = depthColor(event.depthKm || 0);
const fillAlpha = faded
? SELECTED_DISC_ALPHA
: event.mag >= 5.0
? 0.4
: 0.3;
return {
id: `${PICK_PREFIX}${event.stableId}`,
geometry: {
kind: 'ellipse',
center: { lon: event.lon, lat: event.lat },
semiMajor: radius,
semiMinor: radius,
},
fill: [r, g, b, fillAlpha],
height: 'clampGround',
clampTo: 'both',
};
}
/** Fade one disc's flat fill (and restore the one faded before). */
function fadeDisc(stableId) {
if (!ripples || !_discs || _fadedDiscId === stableId) return;
const changed = [];
const before = _eventById.get(_fadedDiscId);
if (before) changed.push(discItem(before, false));
const next = _eventById.get(stableId);
if (next) changed.push(discItem(next, true));
_fadedDiscId = next ? stableId : null;
if (changed.length) _discs.upsert(changed);
}
/** The drawn event a pick id names, or null. */
function eventOfPickId(pickId) {
if (typeof pickId !== 'string' || !pickId.startsWith(PICK_PREFIX))
return null;
return _eventById.get(pickId.slice(PICK_PREFIX.length)) ?? null;
}
/** The drawn event a click's draw hit is on: an item of this layer's set. */
function pickedEvent(hit) {
if (!hit || hit.surface || !_discs || hit.set !== _discs.id) return null;
return eventOfPickId(hit.id);
}
/**
* Show the selected quake's card, context and contours. `user`: a click or
* a label's activation, which claims the shared selection and runs the
* contours again; a feed refresh only brings them up to date, so it never
* takes back a selection made since, nor restarts the animation.
*/
function publishCard({ user = false } = {}) {
const event = _selectedId ? _eventById.get(_selectedId) : null;
if (!_enabled || !event) {
clearSelection();
return;
}
const { title, details, link, accessibilityLabel } = describeEarthquake(
event,
text,
);
_selectedLink = link && openExternal ? link : null;
const card = {
id: `earthquake-card:${event.stableId}`,
selected: true,
// Always hit-testable (the host only hit-tests interactive entries),
// so a click on a card with no link keeps it rather than falling
// through to the ground under it and clearing the selection.
interactive: true,
title,
details,
accent: depthAccent(event.depthKm || 0),
priority: Number.MAX_SAFE_INTEGER,
gapPx: 15,
verticalOnly: true,
placement: 'above',
stateless: true,
horizonCull: true,
position: fromDegrees(event.lon, event.lat),
};
if (_selectedLink) {
const target = _selectedLink;
card.accessibilityLabel = accessibilityLabel;
card.activate = () => {
openExternal(target);
return true;
};
}
_selectedCardId = card.id;
overlayHost.setEntries(
EARTHQUAKE_CARD_SOURCE_ID,
[card],
CARD_HOST_OPTIONS,
);
overlayHost.setVisible(EARTHQUAKE_CARD_SOURCE_ID, true);
publishContext(event, user);
fadeDisc(event.stableId);
ripples?.show?.(
{
id: event.stableId,
lon: event.lon,
lat: event.lat,
radiusM: earthquakeDiscRadiusM(event.mag),
color: depthAccent(event.depthKm || 0),
},
{ restart: user },
);
}
/**
* Select the event in the shared context store, so "what's selected"
* (voice, the Cockpit) answers with it, as a clicked fire does.
*/
function publishContext(event, select) {
if (!context) return;
const id = `${PICK_PREFIX}${event.stableId}`;
try {
if (_contextId && _contextId !== id)
context.getContextStore().entities.delete(_contextId);
const carrier = { show: true };
context.registerEntityContext(carrier, {
id,
layerId: EARTHQUAKES_LAYER_ID,
layerName: layer.name,
source: 'USGS',
// Hidden with the layer: the context store reads its `show`.
dataSource: _discs,
targetPosition: fromDegrees(event.lon, event.lat),
// i18n-ignore: English entity label, as the analyst records are
label: `Earthquake · ${earthquakeMarkLabel(event)}`,
latitude: event.lat,
longitude: event.lon,
properties: {
magnitude: event.mag,
depthKm: event.depthKm ?? null,
place: event.place ?? null,
time: Number.isFinite(event.time)
? new Date(event.time).toISOString()
: null,
usgsId: event.usgsId ?? null,
},
});
_contextId = id;
if (select) context.selectEntityContext(carrier);
} catch {
// No context store (no window): the card still shows.
}
}
function clearContext() {
if (!context || !_contextId) return;
try {
context.clearSelectedEntityContextForLayer(EARTHQUAKES_LAYER_ID);
context.getContextStore().entities.delete(_contextId);
} catch {
// store unavailable: nothing to clean
}
_contextId = null;
}
function clearSelection() {
const had = _selectedId || _selectedCardId;
_selectedId = null;
_selectedCardId = null;
_selectedLink = null;
clearContext();
ripples?.hide?.();
fadeDisc(null);
if (had)
overlayHost.setEntries(EARTHQUAKE_CARD_SOURCE_ID, [], CARD_HOST_OPTIONS);
}
function installClickHandler() {
if (!canSelect() || _clickHandler || !_viewer) return;
picking.registerPickOwner?.(
EARTHQUAKES_LAYER_ID,
(pickedId) => _enabled && eventOfPickId(pickedId) !== null,
);
// A viewer with no renderer input bound takes no clicks.
let clicks = null;
try {
clicks = input(_viewer) ?? null;
} catch {
clicks = null;
}
if (!clicks) return;
_clickHandler = clicks.onClick((click) => {
if (!_enabled || (pointer && !pointer.isPointerFree())) return;
const at = click.screenPosition;
const cardHit = overlayHost.hitTest?.(at?.x, at?.y, {
sourceId: EARTHQUAKE_CARD_SOURCE_ID,
});
if (cardHit && cardHit.entryId === _selectedCardId) {
if (_selectedLink) openExternal(_selectedLink);
return;
}
// Another layer's pick (an aircraft, a camera) is not this layer's,
// even under a magnitude label: that layer handles it, and this card
// stays. Checked before the labels, as the fire layer does.
const pickId = click.topHit
? (picking.resolvePickId(click.topHit) ?? null)
: null;
if (pickId && picking.isOwnedByOtherLayer(EARTHQUAKES_LAYER_ID, pickId))
return;
// A magnitude label is what a far view (the whole globe) can click:
// it selects the quake and flies to it.
const labelHit = overlayHost.hitTest?.(at?.x, at?.y, {
sourceId: EARTHQUAKE_OVERLAY_SOURCE_ID,
});
if (labelHit && _eventById.has(labelHit.entryId)) {
selectAndFocus(labelHit.entryId);
return;
}
const event = pickedEvent(click.drawHit ?? click.topHit);
if (event) {
_selectedId = event.stableId;
publishCard({ user: true });
return;
}
clearSelection();
});
}
/** Select a drawn quake, show its card, and ask the camera to go there. */
function selectAndFocus(stableId) {
const event = _eventById.get(stableId);
if (!_enabled || !event) return false;
_selectedId = stableId;
publishCard({ user: true });
focus?.requestWorldFocus?.({
kind: 'earthquake',
id: `${PICK_PREFIX}${stableId}`,
label: earthquakeMagnitudeTitle(event.mag),
position: fromDegrees(event.lon, event.lat),
});
return true;
}
function removeClickHandler() {
_clickHandler?.();
_clickHandler = null;
picking?.unregisterPickOwner?.(EARTHQUAKES_LAYER_ID);
}
const layer = {
id: 'earthquakes',
@@ -93,6 +408,7 @@ 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);
installClickHandler();
coverageChanged();
},
@@ -101,6 +417,10 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) {
_request = null;
_enabled = false;
if (_discs) _discs.show = false;
removeClickHandler();
clearSelection();
overlayHost.clearSource(EARTHQUAKE_CARD_SOURCE_ID);
overlayHost.setVisible(EARTHQUAKE_CARD_SOURCE_ID, false);
overlayHost.clearSource(EARTHQUAKE_OVERLAY_SOURCE_ID);
overlayHost.setVisible(EARTHQUAKE_OVERLAY_SOURCE_ID, false);
coverageChanged();
@@ -132,41 +452,52 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) {
time,
} of rows) {
count++;
const baseRadius = Math.pow(2, mag) * 1000;
const color = depthColor(depthKm || 0);
const [r, g, b] = color;
const isSignificant = mag >= 5.0;
const fillAlpha = isSignificant ? 0.4 : 0.3;
const position = fromDegrees(lon, lat);
nextEvents.push({ usgsId, mag, place, time, depthKm, lon, lat });
// A filled disc on the ground, with static axes: re-tessellating
// clamped ground geometry every frame is what once cost 30 fps.
// No outline: clamped to the ground, Cesium never drew one.
nextDiscs.push({
id: `earthquake:${stableId}`,
geometry: {
kind: 'ellipse',
center: { lon, lat },
semiMajor: baseRadius,
semiMinor: baseRadius,
},
fill: [r, g, b, fillAlpha],
height: 'clampGround',
clampTo: 'both',
});
overlayEntries.push(
createEarthquakeOverlayEntry({
id: String(stableId),
position,
magnitude: mag,
accent: depthAccent(depthKm || 0),
}),
const event = {
stableId: String(stableId),
usgsId,
mag,
place,
time,
depthKm,
lon,
lat,
};
nextEvents.push(event);
nextDiscs.push(
discItem(event, Boolean(ripples) && event.stableId === _selectedId),
);
const label = createEarthquakeOverlayEntry({
id: String(stableId),
position,
magnitude: mag,
accent: depthAccent(depthKm || 0),
});
if (canSelect()) {
const id = String(stableId);
label.interactive = true;
label.accessibilityLabel = earthquakeZoomLabel(
{ mag, place },
text,
);
label.activate = () => selectAndFocus(id);
}
overlayEntries.push(label);
}
// Bigger quakes first, so a small quake inside a big one's disc is
// drawn, and picked, on top of it.
nextDiscs.sort((a, b) => b.geometry.semiMajor - a.geometry.semiMajor);
_discs.set(nextDiscs);
_events = nextEvents;
_eventById = new Map(
nextEvents.map((event) => [event.stableId, event]),
);
_fadedDiscId =
ripples && _eventById.has(_selectedId) ? _selectedId : null;
// A selected quake still in the feed keeps its card, refreshed; one
// that left the 24 h window loses it.
if (_selectedId) publishCard();
coverageChanged();
if (_enabled) {
overlayHost.setEntries(
@@ -199,13 +530,19 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) {
destroy(viewer = _viewer) {
_request?.abort();
_request = null;
removeClickHandler();
clearSelection();
ripples?.dispose?.();
_viewer = null;
_enabled = false;
overlayHost.clearSource(EARTHQUAKE_CARD_SOURCE_ID);
overlayHost.setVisible(EARTHQUAKE_CARD_SOURCE_ID, false);
overlayHost.clearSource(EARTHQUAKE_OVERLAY_SOURCE_ID);
overlayHost.setVisible(EARTHQUAKE_OVERLAY_SOURCE_ID, false);
_discs?.dispose();
_discs = null;
_events = [];
_eventById = new Map();
_uncover?.();
_uncover = null;
_marksKey = null;
+292
View File
@@ -123,6 +123,298 @@ export function createEarthquakeOverlayEntry({
};
}
/** Where USGS publishes one event's page, its event id appended. */
export const USGS_EVENT_PAGE_URL =
'https://earthquake.usgs.gov/earthquakes/eventpage/';
/**
* The USGS page for an event id, or null when there is no usable id (a
* fallback `event-N` id never names a USGS page, and is never sent).
* @param {unknown} usgsId
* @returns {string|null}
*/
export function earthquakeEventLink(usgsId) {
const id =
typeof usgsId === 'string' || typeof usgsId === 'number'
? String(usgsId).trim()
: '';
return /^[A-Za-z0-9_-]{1,64}$/.test(id)
? `${USGS_EVENT_PAGE_URL}${id}`
: null;
}
// The package carries no i18n: with no translator given, the card stays
// English, its `{name}` slots filled in.
const english = (text, values) =>
String(text).replace(/\{(\w+)\}/g, (all, key) =>
values && Object.hasOwn(values, key) ? String(values[key]) : all,
);
const utcMinute = (time) =>
`${new Date(time).toISOString().slice(0, 16).replace('T', ' ')} UTC`;
const oneDecimal = (value) => String(Math.round(value * 10) / 10);
/**
* The detail card one clicked earthquake shows: its magnitude as the title,
* then where, when and how deep, and the source. With a USGS event id the
* card opens that event's page.
* @param {{mag: number, place?: string|null, time?: number|null,
* depthKm?: number|null, usgsId?: string|null}} event
* @param {object} [text] The application's formatters.
* @param {(text: string, values?: object) => string} [text.t] Translator.
* @param {(time: number) => string} [text.formatTime] An event time.
* @param {(value: number) => string} [text.formatDepth] A depth in km.
* @returns {{title: string, details: string[], link: string|null,
* accessibilityLabel: string}}
*/
export function describeEarthquake(
event,
{ t = english, formatTime = utcMinute, formatDepth = oneDecimal } = {},
) {
const details = [];
// Severity at a glance, right under the title: the class meter, then
// where in the crust it broke.
const glance = [earthquakeSeverityMeter(event?.mag)];
if (Number.isFinite(event?.depthKm)) {
glance.push(
`${earthquakeDepthBandName(event.depthKm, t)} · ${t('{km} km deep', {
km: formatDepth(event.depthKm),
})}`,
);
}
details.push(glance.join(' '));
const place =
typeof event?.place === 'string'
? event.place.replace(/\s+/g, ' ').trim()
: '';
if (place) details.push(place);
if (Number.isFinite(event?.time)) details.push(formatTime(event.time));
details.push(t('Source: {value}', { value: 'USGS' }));
const link = earthquakeEventLink(event?.usgsId);
if (link) details.push(t('Click the card to open the source ↗'));
const title = `${earthquakeMagnitudeTitle(event?.mag)} · ${earthquakeSeverityName(
event?.mag,
t,
)}`;
return {
title,
details,
link,
accessibilityLabel: t('Open the source for {title}', { title }),
};
}
/**
* USGS's magnitude classes, weakest first: minor (under 4; the feed starts
* at M2.5), light, moderate, strong, major, great (8 and up).
*/
export const EARTHQUAKE_SEVERITY_LEVELS = 6;
/**
* A magnitude's USGS class, 0 (minor) to 5 (great).
* @param {number} magnitude
* @returns {number}
*/
export function earthquakeSeverityLevel(magnitude) {
const mag = Number(magnitude);
if (!Number.isFinite(mag) || mag < 4) return 0;
return Math.min(EARTHQUAKE_SEVERITY_LEVELS - 1, Math.floor(mag) - 3);
}
/** A magnitude's class, as a word in the page's language. */
export function earthquakeSeverityName(magnitude, t = english) {
switch (earthquakeSeverityLevel(magnitude)) {
case 5:
return t('Great', { context: 'earthquake' });
case 4:
return t('Major', { context: 'earthquake' });
case 3:
return t('Strong', { context: 'earthquake' });
case 2:
return t('Moderate', { context: 'earthquake' });
case 1:
return t('Light', { context: 'earthquake' });
default:
return t('Minor', { context: 'earthquake' });
}
}
/**
* The class as a six-step meter, one filled block per class up to this one:
* `■■□□□□` for a light quake. Plain text, so the card shows it as it is.
* @param {number} magnitude
* @returns {string}
*/
export function earthquakeSeverityMeter(magnitude) {
const filled = earthquakeSeverityLevel(magnitude) + 1;
return '■'.repeat(filled) + '□'.repeat(EARTHQUAKE_SEVERITY_LEVELS - filled);
}
/**
* The depth band the disc's colour shows, as a word: shallow (under 70 km,
* red), intermediate (to 300 km, orange), deep (yellow).
*/
export function earthquakeDepthBandName(depthKm, t = english) {
const band = depthBand(depthKm);
if (band === SHALLOW) return t('Shallow', { context: 'earthquake' });
if (band === INTERMEDIATE)
return t('Intermediate', { context: 'earthquake' });
return t('Deep', { context: 'earthquake' });
}
/**
* A quake's disc radius on the ground, in metres: it doubles with each
* magnitude step (about 5.7 km at M2.5, 32 km at M5, 64 km at M6).
* @param {number} magnitude
* @returns {number}
*/
export const earthquakeDiscRadiusM = (magnitude) =>
Math.pow(2, magnitude) * 1000;
/** How many contour lines run out from a selected quake at once. */
export const EARTHQUAKE_RIPPLE_RINGS = 6;
/** How long one contour line takes from the marker to the disc's edge. */
export const EARTHQUAKE_RIPPLE_PERIOD_MS = 4800;
/** Every this many lines one is an index contour, drawn heavier. */
export const EARTHQUAKE_INDEX_CONTOUR_EVERY = 3;
/**
* How far a contour line dents in from the circle, as a share of its
* radius. Kept with the drift below so nested lines never cross: a line's
* radius grows with `fraction` faster than its dents move (see
* earthquakeContourScale).
*/
export const EARTHQUAKE_CONTOUR_WOBBLE = 0.24;
const CONTOUR_HARMONICS = Object.freeze([2, 3, 5]);
const CONTOUR_WEIGHTS = Object.freeze([1, 0.6, 0.3]);
const CONTOUR_MAX_DRIFT = 1.5;
/** A stable 32-bit hash of a string (FNV-1a). */
function hashString(text) {
let h = 0x811c9dc5;
for (const ch of String(text ?? '')) {
h ^= ch.codePointAt(0);
h = Math.imul(h, 0x01000193);
}
return h >>> 0;
}
/**
* One quake's contour shape: a few harmonics around the circle, each with
* its own phase and a drift that turns it as a line runs outward, seeded by
* the quake's id so the same quake always draws the same contours.
* @param {string} seed The quake's stable id.
* @returns {ReadonlyArray<{harmonic: number, weight: number, phase: number, drift: number}>}
*/
export function earthquakeContourShape(seed) {
let state = hashString(seed) || 1;
// xorshift32: a small, stable stream from the seed.
const next = () => {
state ^= state << 13;
state ^= state >>> 17;
state ^= state << 5;
return (state >>> 0) / 0x100000000;
};
return Object.freeze(
CONTOUR_HARMONICS.map((harmonic, i) =>
Object.freeze({
harmonic,
weight: CONTOUR_WEIGHTS[i],
phase: next() * 2 * Math.PI,
drift: (next() * 2 - 1) * CONTOUR_MAX_DRIFT,
}),
),
);
}
/**
* Where a contour line runs at `angle` (radians), as a share of a circle of
* the same `fraction`: between 1 - EARTHQUAKE_CONTOUR_WOBBLE and 1, so the
* outermost line never leaves the disc. The dents turn as `fraction` grows,
* and no faster than the line grows, so lines never cross: with wobble A
* and drift D, d(fraction · scale)/d(fraction) ≥ 1 - A - A·D/2 > 0.
* @param {ReturnType<typeof earthquakeContourShape>} shape
* @param {number} angle
* @param {number} fraction 0 at the marker, 1 at the disc's edge.
* @returns {number}
*/
export function earthquakeContourScale(shape, angle, fraction) {
let sum = 0;
let total = 0;
for (const { harmonic, weight, phase, drift } of shape) {
sum += weight * Math.sin(harmonic * angle + phase + drift * fraction);
total += weight;
}
const n = total > 0 ? sum / total : 0;
return 1 - (EARTHQUAKE_CONTOUR_WOBBLE * (1 - n)) / 2;
}
/**
* The selected quake's contour lines at a time: each runs from the marker
* (`fraction` 0) out to the disc's edge (1), evenly staggered, fading in
* just after it starts and out as it reaches the edge; every
* EARTHQUAKE_INDEX_CONTOUR_EVERY-th is an index contour. Pure: the painter
* gives the clock.
* @param {number} timeMs Any steady clock, in milliseconds.
* @param {{count?: number, periodMs?: number}} [options]
* @returns {Array<{fraction: number, alpha: number, index: boolean}>}
*/
export function earthquakeRippleRings(
timeMs,
{
count = EARTHQUAKE_RIPPLE_RINGS,
periodMs = EARTHQUAKE_RIPPLE_PERIOD_MS,
} = {},
) {
const phase = Number.isFinite(timeMs) && periodMs > 0 ? timeMs / periodMs : 0;
const rings = [];
for (let k = 0; k < count; k++) {
const fraction = (((phase + k / count) % 1) + 1) % 1;
rings.push({
fraction,
alpha: earthquakeRippleAlpha(fraction),
index: k % EARTHQUAKE_INDEX_CONTOUR_EVERY === 0,
});
}
return rings;
}
/**
* Still contour lines, for viewers who ask for reduced motion: the same
* lines as the animation, held evenly spaced out to the edge.
* @param {number} [count]
* @returns {Array<{fraction: number, alpha: number, index: boolean}>}
*/
export function earthquakeContourRings(count = EARTHQUAKE_RIPPLE_RINGS) {
const rings = [];
for (let k = 1; k <= count; k++)
rings.push({
fraction: k / count,
alpha: 0.7,
index: k % EARTHQUAKE_INDEX_CONTOUR_EVERY === 0,
});
return rings;
}
const RIPPLE_FADE_IN = 0.12;
/** A ring's opacity where it is: in from 0 near the marker, out to 0 at the edge. */
function earthquakeRippleAlpha(fraction) {
if (fraction <= 0 || fraction >= 1) return 0;
return fraction < RIPPLE_FADE_IN
? fraction / RIPPLE_FADE_IN
: (1 - fraction) / (1 - RIPPLE_FADE_IN);
}
/**
* What a magnitude label says to assistive technology: activating it zooms
* to the quake (`Zoom to M5.0 · 42 km SW of Anchorage, Alaska`).
* @param {{mag: number, place?: string|null}} event
* @param {{t?: (text: string, values?: object) => string}} [text]
* @returns {string}
*/
export function earthquakeZoomLabel(event, { t = english } = {}) {
return t('Zoom to {name}', { name: earthquakeMarkLabel(event) });
}
/** Keep the largest events, with stable identity as the tie-break. */
export function selectEarthquakeOverlayCohort(
entries,
+610
View File
@@ -0,0 +1,610 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
import * as picking from '../../data/pickRegistry.js';
import {
EARTHQUAKE_CARD_SOURCE_ID,
EARTHQUAKE_OVERLAY_SOURCE_ID,
createEarthquakesLayer,
describeEarthquake,
earthquakeEventLink,
earthquakeRippleRings,
earthquakeContourRings,
earthquakeContourShape,
earthquakeContourScale,
EARTHQUAKE_CONTOUR_WOBBLE,
EARTHQUAKE_RIPPLE_PERIOD_MS,
earthquakeSeverityName,
earthquakeSeverityMeter,
earthquakeDepthBandName,
} from './index.js';
const quake = (id, extra = {}) => ({
stableId: id,
usgsId: id,
lon: -153.3,
lat: 60.0,
depthKm: 112.4,
mag: 2.5,
place: '42 km W of Fixture, Alaska',
time: Date.UTC(2026, 10, 13, 15, 37),
...extra,
});
/** A layer whose globe clicks, card hits and context store the test drives. */
function harness(rows, { context = null, ripples = null } = {}) {
let snapshot = rows;
const handlers = [];
const opened = [];
const cards = [];
const visible = new Map();
const labels = [];
const focused = [];
// What the overlay hit test finds under the click, per source.
const overlayHits = new Map();
const viewer = {};
const { draw } = bindFakeDraw(viewer);
const layer = createEarthquakesLayer({
source: { getSnapshot: async () => snapshot },
overlayHost: {
setEntries(sourceId, entries) {
if (sourceId === EARTHQUAKE_CARD_SOURCE_ID) cards.push(entries);
if (sourceId === EARTHQUAKE_OVERLAY_SOURCE_ID) labels.push(entries);
},
setVisible: (sourceId, show) => visible.set(sourceId, show),
clearSource() {},
// As the real host does, only an interactive entry painted now is hit.
hitTest(_x, _y, { sourceId }) {
const hit = overlayHits.get(sourceId);
const painted =
sourceId === EARTHQUAKE_CARD_SOURCE_ID ? cards.at(-1) : labels.at(-1);
const entry = painted?.find((e) => e.id === hit?.entryId);
return hit && entry?.interactive === true ? hit : null;
},
},
input: () => ({
onClick(callback) {
const handler = { callback, destroyed: false };
handlers.push(handler);
return () => {
handler.destroyed = true;
};
},
}),
picking,
context,
ripples,
pointer: { isPointerFree: () => true },
openExternal: (url) => opened.push(url),
focus: {
requestWorldFocus: (detail) => {
focused.push(detail);
return true;
},
},
});
layer.init(viewer);
const discs = () => draw.find('earthquakes:');
const live = () => handlers.filter((h) => !h.destroyed);
return {
layer,
viewer,
opened,
cards,
visible,
focused,
handlers,
discs,
setRows(next) {
snapshot = next;
},
/** Click a quake's disc (by stable id), something else, or the map. */
click(hit) {
for (const { callback } of live())
callback({
screenPosition: { x: 10, y: 10 },
topHit: hit,
drawHit: hit && !hit.surface ? hit : null,
});
},
clickDisc(id) {
this.click({ set: discs().spec.id, id: `earthquake:${id}` });
},
clickCard(entryId) {
this.clickOverlay(EARTHQUAKE_CARD_SOURCE_ID, entryId);
},
/** Click a magnitude label, as the overlay host paints it. */
clickLabel(id) {
this.clickOverlay(EARTHQUAKE_OVERLAY_SOURCE_ID, id);
},
clickOverlay(sourceId, entryId) {
this.clickOverlayWith(sourceId, entryId, null);
},
/** Click an overlay entry with `hit` drawn under the same pixel. */
clickOverlayWith(sourceId, entryId, hit) {
overlayHits.set(sourceId, { sourceId, entryId });
this.click(hit);
overlayHits.delete(sourceId);
},
lastCard: () => cards.at(-1),
lastLabels: () => labels.at(-1),
};
}
test('clicking a quake disc shows its detail card; empty map clears it', async () => {
const h = harness([quake('ak1'), quake('ak2', { mag: 4.1 })]);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
assert.equal(h.cards.length, 0, 'no card before a click');
h.clickDisc('ak2');
const [card] = h.lastCard();
assert.equal(card.id, 'earthquake-card:ak2');
assert.equal(card.title, 'M4.1 · Light');
assert.deepEqual(card.details, [
'■■□□□□ Intermediate · 112.4 km deep',
'42 km W of Fixture, Alaska',
'2026-11-13 15:37 UTC',
'Source: USGS',
'Click the card to open the source ↗',
]);
assert.equal(card.interactive, true);
assert.equal(card.accessibilityLabel, 'Open the source for M4.1 · Light');
assert.equal(h.visible.get(EARTHQUAKE_CARD_SOURCE_ID), true);
h.click(null);
assert.deepEqual(h.lastCard(), [], 'a click on the map clears the card');
h.layer.destroy();
});
test('the card opens the USGS event page, from a click or the keyboard', async () => {
const h = harness([quake('ak1')]);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
h.clickDisc('ak1');
h.clickCard('earthquake-card:ak1');
assert.deepEqual(h.opened, [
'https://earthquake.usgs.gov/earthquakes/eventpage/ak1',
]);
assert.equal(h.lastCard()[0].activate(), true);
assert.equal(h.opened.length, 2);
assert.equal(h.lastCard().length, 1, 'opening the source keeps the card');
h.layer.destroy();
});
test('a quake with no USGS id gets a card with no link', async () => {
const h = harness([quake('event-1', { usgsId: null })]);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
h.clickDisc('event-1');
const [card] = h.lastCard();
assert.equal(card.interactive, true, 'hit-testable, so a click keeps it');
assert.equal(card.activate, undefined);
assert.equal(card.accessibilityLabel, undefined, 'no action to offer');
assert.ok(!card.details.some((line) => line.includes('Click the card')));
h.clickCard(card.id);
assert.deepEqual(h.opened, []);
assert.equal(h.lastCard()[0].id, card.id, 'the card stays');
h.layer.destroy();
});
test("another layer's pick leaves the card; its own pick ids are claimed", async () => {
const h = harness([quake('ak1')]);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
assert.equal(picking.findPickOwner('earthquake:ak1'), 'earthquakes');
assert.equal(picking.findPickOwner('earthquake:gone'), null);
picking.registerPickOwner('test-other', (id) => id === 'plane-1');
try {
h.clickDisc('ak1');
const before = h.cards.length;
h.click({ set: 'flights:1', id: 'plane-1' });
assert.equal(h.cards.length, before, 'the card stays');
// A pick of the same id from another set is not a quake.
h.click({ set: 'other:1', id: 'earthquake:ak1' });
assert.deepEqual(h.lastCard(), []);
} finally {
picking.unregisterPickOwner('test-other');
h.layer.destroy();
}
assert.equal(picking.findPickOwner('earthquake:ak1'), null);
});
test('a refresh keeps the selected quake while it is in the feed', async () => {
const h = harness([quake('ak1'), quake('ak2')]);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
h.clickDisc('ak1');
h.setRows([quake('ak1', { mag: 2.7 }), quake('ak2')]);
await h.layer.update(h.viewer);
assert.equal(
h.lastCard()[0].title,
'M2.7 · Minor',
'the card follows the feed',
);
h.setRows([quake('ak2')]);
await h.layer.update(h.viewer);
assert.deepEqual(h.lastCard(), [], 'a quake that left the feed loses it');
h.layer.destroy();
});
test('disable removes the click handler and the card', async () => {
const h = harness([quake('ak1')]);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
h.clickDisc('ak1');
h.layer.disable(h.viewer);
assert.deepEqual(h.lastCard(), []);
assert.equal(
h.handlers.every((handler) => handler.destroyed),
true,
);
assert.equal(picking.findPickOwner('earthquake:ak1'), null);
h.layer.enable(h.viewer);
assert.equal(
h.handlers.filter((handler) => !handler.destroyed).length,
1,
'one handler again, not two',
);
h.layer.destroy();
});
test('a small quake inside a big one is drawn on top of it', async () => {
const h = harness([quake('small', { mag: 2.6 }), quake('big', { mag: 6 })]);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
assert.deepEqual(
[...h.discs().items.keys()],
['earthquake:big', 'earthquake:small'],
);
h.layer.destroy();
});
test('the clicked quake is the selected context, cleared with the card', async () => {
const entities = new Map();
const calls = [];
const context = {
getContextStore: () => ({ entities }),
registerEntityContext(carrier, metadata) {
entities.set(metadata.id, { ...metadata, entity: carrier });
},
selectEntityContext: (carrier) => calls.push(['select', carrier]),
clearSelectedEntityContextForLayer: (layerId) =>
calls.push(['clear', layerId]),
};
const h = harness([quake('ak1'), quake('ak2')], { context });
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
h.clickDisc('ak1');
const record = entities.get('earthquake:ak1');
assert.equal(record.layerId, 'earthquakes');
assert.equal(record.label, 'Earthquake · M2.5 · 42 km W of Fixture, Alaska');
assert.equal(record.properties.usgsId, 'ak1');
assert.equal(record.dataSource.show, true, 'hidden with the discs');
assert.equal(calls.at(-1)[0], 'select');
h.clickDisc('ak2');
assert.deepEqual([...entities.keys()], ['earthquake:ak2'], 'one record');
h.click(null);
assert.equal(entities.size, 0);
assert.deepEqual(calls.at(-1), ['clear', 'earthquakes']);
h.layer.destroy();
});
test('without click services the layer draws and takes no clicks', async () => {
const viewer = {};
bindFakeDraw(viewer);
const layer = createEarthquakesLayer({
source: { getSnapshot: async () => [quake('ak1')] },
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
});
layer.init(viewer);
layer.enable(viewer);
assert.equal(await layer.update(viewer), true);
assert.equal(picking.findPickOwner('earthquake:ak1'), null);
layer.destroy();
});
test('describeEarthquake translates through the given formatters', () => {
const card = describeEarthquake(quake('ak1', { place: ' far away ' }), {
t: (text, values) => `<${text}>${JSON.stringify(values ?? {})}`,
formatTime: () => 'TIME',
formatDepth: (km) => `~${km}`,
});
assert.equal(card.title, 'M2.5 · <Minor>{"context":"earthquake"}');
assert.deepEqual(card.details, [
'■□□□□□ <Intermediate>{"context":"earthquake"} · <{km} km deep>{"km":"~112.4"}',
'far away',
'TIME',
'<Source: {value}>{"value":"USGS"}',
'<Click the card to open the source ↗>{}',
]);
const bare = describeEarthquake({ mag: 3, place: null, time: null });
assert.equal(bare.title, 'M3.0 · Minor');
assert.deepEqual(bare.details, ['■□□□□□', 'Source: USGS']);
assert.equal(bare.link, null);
});
test('severity follows the USGS magnitude classes; depth bands the disc colours', () => {
const cases = [
[2.5, 'Minor', '■□□□□□'],
[3.99, 'Minor', '■□□□□□'],
[4, 'Light', '■■□□□□'],
[5.4, 'Moderate', '■■■□□□'],
[6.1, 'Strong', '■■■■□□'],
[7.8, 'Major', '■■■■■□'],
[8.2, 'Great', '■■■■■■'],
[9.5, 'Great', '■■■■■■'],
[Number.NaN, 'Minor', '■□□□□□'],
];
for (const [mag, name, meter] of cases) {
assert.equal(earthquakeSeverityName(mag), name, String(mag));
assert.equal(earthquakeSeverityMeter(mag), meter, String(mag));
}
assert.equal(earthquakeDepthBandName(10), 'Shallow');
assert.equal(earthquakeDepthBandName(69.9), 'Shallow');
assert.equal(earthquakeDepthBandName(70), 'Intermediate');
assert.equal(earthquakeDepthBandName(299), 'Intermediate');
assert.equal(earthquakeDepthBandName(300), 'Deep');
});
test('earthquakeEventLink accepts only plain USGS ids', () => {
assert.equal(
earthquakeEventLink('us7000abcd'),
'https://earthquake.usgs.gov/earthquakes/eventpage/us7000abcd',
);
for (const bad of [null, '', ' ', '../x', 'a/b', 'a?b=1', 'x'.repeat(65)])
assert.equal(earthquakeEventLink(bad), null, String(bad));
});
test('clicking a magnitude label selects the quake and flies to it', async () => {
const h = harness([
quake('ak1'),
quake('jp1', { mag: 5, lon: 142, lat: 38 }),
]);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
const label = h.lastLabels().find((entry) => entry.id === 'jp1');
assert.equal(label.interactive, true, 'labels take clicks');
assert.equal(
label.accessibilityLabel,
'Zoom to M5.0 · 42 km W of Fixture, Alaska',
);
h.clickLabel('jp1');
assert.equal(h.lastCard()[0].id, 'earthquake-card:jp1');
assert.equal(h.focused.length, 1);
const [detail] = h.focused;
assert.equal(detail.kind, 'earthquake');
assert.equal(detail.id, 'earthquake:jp1');
assert.equal(detail.label, 'M5.0');
assert.ok(
Math.hypot(detail.position.x, detail.position.y, detail.position.z) > 6e6,
);
// The keyboard path does the same.
assert.equal(
h
.lastLabels()
.find((e) => e.id === 'ak1')
.activate(),
true,
);
assert.equal(h.lastCard()[0].id, 'earthquake-card:ak1');
assert.equal(h.focused.at(-1).id, 'earthquake:ak1');
// A disc click only selects: the camera stays where it is.
h.clickDisc('jp1');
assert.equal(h.focused.length, 2);
assert.equal(h.lastCard()[0].id, 'earthquake-card:jp1');
// A label id the layer no longer draws is not a quake.
h.clickLabel('gone');
assert.deepEqual(h.lastCard(), []);
assert.equal(h.focused.length, 2);
h.layer.destroy();
});
test('without click services the labels stay non-interactive', async () => {
const viewer = {};
bindFakeDraw(viewer);
const published = [];
const layer = createEarthquakesLayer({
source: { getSnapshot: async () => [quake('ak1')] },
overlayHost: {
setEntries: (_source, entries) => published.push(entries),
setVisible() {},
clearSource() {},
},
});
layer.init(viewer);
layer.enable(viewer);
await layer.update(viewer);
const [label] = published.at(-1);
assert.equal(label.interactive, false);
assert.equal(label.activate, undefined);
layer.destroy();
});
test('the selected quake runs contour rings to its disc edge; clearing stops them', async () => {
const calls = [];
const ripples = {
show: (target) => calls.push(['show', target]),
hide: () => calls.push(['hide']),
dispose: () => calls.push(['dispose']),
};
const h = harness(
[quake('ak1', { mag: 5, depthKm: 10 }), quake('ak2', { mag: 3 })],
{ ripples },
);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
h.clickDisc('ak1');
const shown = calls.findLast(([kind]) => kind === 'show')[1];
assert.deepEqual(shown, {
id: 'ak1',
lon: -153.3,
lat: 60,
radiusM: 32000,
color: 'rgb(255,0,0)',
});
assert.equal(
h.discs().items.get('earthquake:ak1').geometry.semiMajor,
shown.radiusM,
'the rings end at the disc edge',
);
h.clickDisc('ak2');
assert.equal(calls.findLast(([kind]) => kind === 'show')[1].radiusM, 8000);
h.click(null);
assert.deepEqual(calls.at(-1), ['hide']);
h.clickDisc('ak1');
h.layer.disable(h.viewer);
assert.deepEqual(calls.at(-1), ['hide']);
h.layer.destroy();
assert.deepEqual(calls.at(-1), ['dispose']);
});
test('ripple rings run from the marker to the edge, staggered, fading at both ends', () => {
const rings = earthquakeRippleRings(0, { count: 3, periodMs: 3000 });
assert.deepEqual(
rings.map(({ fraction }) => Number(fraction.toFixed(4))),
[0, 0.3333, 0.6667],
);
assert.equal(rings[0].alpha, 0, 'a ring at the marker is not yet seen');
// Each ring moves outward with time and wraps back to the marker.
const later = earthquakeRippleRings(1000, { count: 3, periodMs: 3000 });
assert.ok(later[1].fraction > rings[1].fraction);
assert.ok(later[2].fraction < rings[2].fraction, 'the outer ring wrapped');
for (let t = 0; t < 6000; t += 37)
for (const { fraction, alpha } of earthquakeRippleRings(t)) {
assert.ok(fraction >= 0 && fraction < 1);
assert.ok(alpha >= 0 && alpha <= 1);
}
const near = (f) =>
earthquakeRippleRings(f * EARTHQUAKE_RIPPLE_PERIOD_MS, { count: 1 })[0]
.alpha;
assert.ok(near(0.99) < 0.02, 'fades out at the edge');
assert.ok(near(0.12) > 0.999, 'fully in just after the start');
assert.deepEqual(
earthquakeContourRings(3).map(({ fraction }) => fraction),
[1 / 3, 2 / 3, 1],
);
});
test('a quake keeps its own contour shape; nested lines never cross', () => {
const a = earthquakeContourShape('us7000abcd');
assert.deepEqual(
earthquakeContourShape('us7000abcd'),
a,
'same id, same shape',
);
assert.notDeepEqual(earthquakeContourShape('ak2026xyz'), a);
for (const id of ['us7000abcd', 'ak2026xyz', 'event-1', '']) {
const shape = earthquakeContourShape(id);
for (let i = 0; i < 180; i++) {
const angle = (2 * Math.PI * i) / 180;
let previous = 0;
for (let step = 1; step <= 200; step++) {
const fraction = step / 200;
const scale = earthquakeContourScale(shape, angle, fraction);
assert.ok(scale <= 1 + 1e-12, 'never past the disc edge');
assert.ok(scale >= 1 - EARTHQUAKE_CONTOUR_WOBBLE - 1e-12);
const reach = fraction * scale;
assert.ok(reach > previous, `${id}: lines cross at ${angle}`);
previous = reach;
}
}
}
});
test("the selected quake's flat disc fades under its gradient and comes back", async () => {
const ripples = { show() {}, hide() {}, dispose() {} };
const h = harness([quake('ak1', { mag: 5 }), quake('ak2')], { ripples });
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
const alpha = (id) => h.discs().items.get(`earthquake:${id}`).fill[3];
assert.equal(alpha('ak1'), 0.4);
h.clickDisc('ak1');
assert.equal(alpha('ak1'), 0.04, 'faint, still pickable');
h.clickDisc('ak2');
assert.equal(alpha('ak1'), 0.4, 'restored');
assert.equal(alpha('ak2'), 0.04);
// A refresh keeps the selected disc faded.
await h.layer.update(h.viewer);
assert.equal(alpha('ak2'), 0.04);
assert.equal(alpha('ak1'), 0.4);
h.click(null);
assert.equal(alpha('ak2'), 0.3);
h.layer.destroy();
});
test('without the ripples painter the selected disc keeps its fill', async () => {
const h = harness([quake('ak1')]);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
h.clickDisc('ak1');
assert.equal(h.discs().items.get('earthquake:ak1').fill[3], 0.3);
h.layer.destroy();
});
test('a feed refresh neither retakes the selection nor restarts the contours', async () => {
const calls = [];
const shows = [];
const entities = new Map();
const context = {
getContextStore: () => ({ entities }),
registerEntityContext(carrier, metadata) {
entities.set(metadata.id, { ...metadata, entity: carrier });
},
selectEntityContext: () => calls.push('select'),
clearSelectedEntityContextForLayer: () => calls.push('clear'),
};
const ripples = {
show: (target, options) => shows.push(options),
hide() {},
dispose() {},
};
const h = harness([quake('ak1', { mag: 4 })], { context, ripples });
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
h.clickDisc('ak1');
assert.deepEqual(calls, ['select']);
assert.deepEqual(shows, [{ restart: true }]);
// Another layer's selection happens here; then the feed refreshes.
h.setRows([quake('ak1', { mag: 4.3 })]);
await h.layer.update(h.viewer);
assert.deepEqual(calls, ['select'], 'not selected again by a refresh');
assert.deepEqual(shows.at(-1), { restart: false });
assert.equal(
entities.get('earthquake:ak1').label,
'Earthquake · M4.3 · 42 km W of Fixture, Alaska',
'the record is kept up to date',
);
// Clicking it again is the user's: it selects and runs again.
h.clickDisc('ak1');
assert.deepEqual(calls, ['select', 'select']);
assert.deepEqual(shows.at(-1), { restart: true });
h.layer.destroy();
});
test("another layer's object over a magnitude label takes the click", async () => {
const h = harness([quake('ak1')]);
h.layer.enable(h.viewer);
await h.layer.update(h.viewer);
picking.registerPickOwner('test-plane', (id) => id === 'plane-9');
try {
// The click lands on the label and on a plane drawn there.
h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak1', {
set: 'flights:1',
id: 'plane-9',
});
assert.equal(h.cards.length, 0, 'the quake is not selected');
assert.equal(h.focused.length, 0, 'and the camera stays');
// The label alone still selects and flies.
h.clickLabel('ak1');
assert.equal(h.lastCard()[0].id, 'earthquake-card:ak1');
assert.equal(h.focused.length, 1);
} finally {
picking.unregisterPickOwner('test-plane');
h.layer.destroy();
}
});